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 "acl_rt_impl.h"
      12             : #include "runtime/event.h"
      13             : #include "runtime/config.h"
      14             : #include "runtime/rt_ras.h"
      15             : #include "runtime/rts/rts_event.h"
      16             : #include "runtime/rts/rts_device.h"
      17             : #include "common/log_inner.h"
      18             : #include "common/error_codes_inner.h"
      19             : #include "common/prof_reporter.h"
      20             : #include "common/resource_statistics.h"
      21             : 
      22           6 : aclError aclrtCreateEventImpl(aclrtEvent *event)
      23             : {
      24          12 :     ACL_PROFILING_REG(acl::AclProfType::AclrtCreateEvent);
      25           6 :     ACL_ADD_APPLY_TOTAL_COUNT(acl::ACL_STATISTICS_CREATE_DESTROY_EVENT);
      26           6 :     ACL_LOG_INFO("start to execute aclrtCreateEvent");
      27           6 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(event);
      28             : 
      29           4 :     rtEvent_t rtEvent = nullptr;
      30           4 :     const rtError_t rtErr = rtEventCreate(&rtEvent);
      31           4 :     if (rtErr != RT_ERROR_NONE) {
      32           2 :         ACL_LOG_CALL_ERROR("create event failed, runtime result = %d", static_cast<int32_t>(rtErr));
      33           2 :         return ACL_GET_ERRCODE_RTS(rtErr);
      34             :     }
      35             : 
      36           2 :     *event = static_cast<aclrtEvent>(rtEvent);
      37           2 :     ACL_LOG_INFO("successfully execute aclrtCreateEvent");
      38           2 :     ACL_ADD_APPLY_SUCCESS_COUNT(acl::ACL_STATISTICS_CREATE_DESTROY_EVENT);
      39           2 :     return ACL_SUCCESS;
      40             : }
      41             : 
      42           6 : aclError aclrtCreateEventWithFlagImpl(aclrtEvent *event, uint32_t flag)
      43             : {
      44          12 :     ACL_PROFILING_REG(acl::AclProfType::AclrtCreateEventWithFlag);
      45           6 :     ACL_ADD_APPLY_TOTAL_COUNT(acl::ACL_STATISTICS_CREATE_DESTROY_EVENT);
      46           6 :     ACL_LOG_INFO("start to execute aclrtCreateEventWithFlag.");
      47           6 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(event);
      48           4 :     rtEvent_t rtEvent = nullptr;
      49           4 :     const rtError_t rtErr = rtEventCreateWithFlag(&rtEvent, flag);
      50           4 :     if (rtErr != RT_ERROR_NONE) {
      51           2 :         ACL_LOG_CALL_ERROR("create event flag failed, runtime result = %d", static_cast<int32_t>(rtErr));
      52           2 :         return ACL_GET_ERRCODE_RTS(rtErr);
      53             :     }
      54           2 :     *event = static_cast<aclrtEvent>(rtEvent);
      55           2 :     ACL_LOG_INFO("successfully execute aclrtCreateEventWithFlag.");
      56           2 :     ACL_ADD_APPLY_SUCCESS_COUNT(acl::ACL_STATISTICS_CREATE_DESTROY_EVENT);
      57           2 :     return ACL_SUCCESS;
      58             : }
      59             : 
      60           4 : aclError aclrtCreateEventExWithFlagImpl(aclrtEvent *event, uint32_t flag)
      61             : {
      62           8 :     ACL_PROFILING_REG(acl::AclProfType::AclrtCreateEventExWithFlag);
      63           4 :     ACL_ADD_APPLY_TOTAL_COUNT(acl::ACL_STATISTICS_CREATE_DESTROY_EVENT);
      64           4 :     ACL_LOG_INFO("start to execute aclrtCreateEventExWithFlag.");
      65           4 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(event);
      66           3 :     rtEvent_t rtEvent = nullptr;
      67           3 :     const rtError_t rtErr = rtEventCreateExWithFlag(&rtEvent, flag);
      68           3 :     if (rtErr != RT_ERROR_NONE) {
      69           2 :         if (rtErr == ACL_ERROR_RT_FEATURE_NOT_SUPPORT) {
      70           1 :             ACL_LOG_WARN("rtEventCreateExWithFlag unsupport, runtime result = %d", static_cast<int32_t>(rtErr));
      71             :         } else {
      72           1 :             ACL_LOG_CALL_ERROR("create event ex with flag failed, runtime result = %d", static_cast<int32_t>(rtErr));
      73             :         }
      74           2 :         return ACL_GET_ERRCODE_RTS(rtErr);
      75             :     }
      76           1 :     *event = static_cast<aclrtEvent>(rtEvent);
      77           1 :     ACL_LOG_INFO("successfully execute aclrtCreateEventExWithFlag.");
      78           1 :     ACL_ADD_APPLY_SUCCESS_COUNT(acl::ACL_STATISTICS_CREATE_DESTROY_EVENT);
      79           1 :     return ACL_SUCCESS;
      80             : }
      81             : 
      82           6 : aclError aclrtDestroyEventImpl(aclrtEvent event)
      83             : {
      84          12 :     ACL_PROFILING_REG(acl::AclProfType::AclrtDestroyEvent);
      85           6 :     ACL_ADD_RELEASE_TOTAL_COUNT(acl::ACL_STATISTICS_CREATE_DESTROY_EVENT);
      86           6 :     ACL_LOG_INFO("start to execute aclrtDestroyEvent");
      87           6 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(event);
      88             : 
      89           4 :     const rtError_t rtErr = rtEventDestroy(static_cast<rtEvent_t>(event));
      90           4 :     if (rtErr != RT_ERROR_NONE) {
      91           2 :         ACL_LOG_CALL_ERROR("destroy event failed, runtime result = %d", static_cast<int32_t>(rtErr));
      92           2 :         return ACL_GET_ERRCODE_RTS(rtErr);
      93             :     }
      94           2 :     ACL_LOG_INFO("successfully execute aclrtDestroyEvent");
      95           2 :     ACL_ADD_RELEASE_SUCCESS_COUNT(acl::ACL_STATISTICS_CREATE_DESTROY_EVENT);
      96           2 :     return ACL_SUCCESS;
      97             : }
      98             : 
      99           6 : aclError aclrtRecordEventImpl(aclrtEvent event, aclrtStream stream)
     100             : {
     101          12 :      ACL_PROFILING_REG(acl::AclProfType::AclrtRecordEvent);
     102           6 :     ACL_ADD_APPLY_TOTAL_COUNT(acl::ACL_STATISTICS_RECORD_RESET_EVENT);
     103           6 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(event);
     104             : 
     105           4 :     const rtError_t rtErr = rtEventRecord(static_cast<rtEvent_t>(event), static_cast<rtStream_t>(stream));
     106           4 :     if (rtErr != RT_ERROR_NONE) {
     107           2 :         ACL_LOG_CALL_ERROR("record event failed, runtime result = %d", static_cast<int32_t>(rtErr));
     108           2 :         return ACL_GET_ERRCODE_RTS(rtErr);
     109             :     }
     110           2 :     ACL_ADD_APPLY_SUCCESS_COUNT(acl::ACL_STATISTICS_RECORD_RESET_EVENT);
     111           2 :     return ACL_SUCCESS;
     112             : }
     113             : 
     114          10 : aclError aclrtResetEventImpl(aclrtEvent event, aclrtStream stream)
     115             : {
     116          20 :     ACL_PROFILING_REG(acl::AclProfType::AclrtResetEvent);
     117          10 :     ACL_ADD_RELEASE_TOTAL_COUNT(acl::ACL_STATISTICS_RECORD_RESET_EVENT);
     118          10 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(event);
     119             : 
     120           6 :     const rtError_t rtErr = rtEventReset(static_cast<rtEvent_t>(event), static_cast<rtStream_t>(stream));
     121           6 :     if (rtErr != RT_ERROR_NONE) {
     122           4 :         ACL_LOG_CALL_ERROR("reset event failed, runtime result = %d", static_cast<int32_t>(rtErr));
     123           4 :         return ACL_GET_ERRCODE_RTS(rtErr);
     124             :     }
     125           2 :     ACL_ADD_RELEASE_SUCCESS_COUNT(acl::ACL_STATISTICS_RECORD_RESET_EVENT);
     126           2 :     return ACL_SUCCESS;
     127             : }
     128             : 
     129           6 : aclError aclrtQueryEventImpl(aclrtEvent event, aclrtEventStatus *status)
     130             : {
     131          12 :     ACL_PROFILING_REG(acl::AclProfType::AclrtQueryEvent);
     132           6 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(event);
     133           6 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(status);
     134             : 
     135           6 :     const rtError_t rtErr = rtEventQuery(static_cast<rtEvent_t>(event));
     136           6 :     if (rtErr == RT_ERROR_NONE) {
     137           2 :         *status = ACL_EVENT_STATUS_COMPLETE;
     138           4 :     } else if (rtErr == ACL_ERROR_RT_EVENT_NOT_COMPLETE) {
     139           2 :         *status = ACL_EVENT_STATUS_NOT_READY;
     140             :     } else {
     141           2 :         ACL_LOG_INNER_ERROR("query event status failed, runtime result = %d", static_cast<int32_t>(rtErr));
     142           2 :         return ACL_GET_ERRCODE_RTS(rtErr);
     143             :     }
     144           4 :     return ACL_SUCCESS;
     145             : }
     146             : 
     147           5 : aclError aclrtQueryEventStatusImpl(aclrtEvent event, aclrtEventRecordedStatus *status)
     148             : {
     149          10 :     ACL_PROFILING_REG(acl::AclProfType::AclrtQueryEventStatus);
     150           5 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(event);
     151           4 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(status);
     152             : 
     153           3 :     rtEventStatus_t rtStatus = RT_EVENT_INIT;
     154           3 :     const rtError_t rtErr = rtEventQueryStatus(static_cast<rtEvent_t>(event), &rtStatus);
     155           3 :     if (rtErr != RT_ERROR_NONE) {
     156           1 :         ACL_LOG_CALL_ERROR("[Query][Status]query event recorded status failed, runtime result = %d",
     157             :             static_cast<int32_t>(rtErr));
     158           1 :         return ACL_GET_ERRCODE_RTS(rtErr);
     159             :     }
     160           2 :     if (rtStatus == RT_EVENT_RECORDED) {
     161           1 :         *status = ACL_EVENT_RECORDED_STATUS_COMPLETE;
     162             :     } else {
     163           1 :         *status = ACL_EVENT_RECORDED_STATUS_NOT_READY;
     164             :     }
     165           2 :     return ACL_SUCCESS;
     166             : }
     167             : 
     168           5 : aclError aclrtQueryEventWaitStatusImpl(aclrtEvent event, aclrtEventWaitStatus *status)
     169             : {
     170          10 :     ACL_PROFILING_REG(acl::AclProfType::AclrtQueryEventWaitStatus);
     171           5 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(event);
     172           4 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(status);
     173             : 
     174           3 :     rtEventWaitStatus_t rtWaitStatus = EVENT_STATUS_NOT_READY;
     175           3 :     const rtError_t rtErr = rtEventQueryWaitStatus(static_cast<rtEvent_t>(event), &rtWaitStatus);
     176           3 :     if (rtErr != RT_ERROR_NONE) {
     177           1 :         ACL_LOG_CALL_ERROR("[Query][Status]query event wait-status failed, runtime result = %d",
     178             :             static_cast<int32_t>(rtErr));
     179           1 :         return ACL_GET_ERRCODE_RTS(rtErr);
     180             :     }
     181           2 :     if (rtWaitStatus == EVENT_STATUS_COMPLETE) {
     182           1 :         *status = ACL_EVENT_WAIT_STATUS_COMPLETE;
     183             :     } else {
     184           1 :         *status = ACL_EVENT_WAIT_STATUS_NOT_READY;
     185             :     }
     186           2 :     return ACL_SUCCESS;
     187             : }
     188             : 
     189           6 : aclError aclrtSynchronizeEventImpl(aclrtEvent event)
     190             : {
     191          12 :     ACL_PROFILING_REG(acl::AclProfType::AclrtSynchronizeEvent);
     192           6 :     ACL_LOG_INFO("start to execute aclrtSynchronizeEvent");
     193           6 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(event);
     194             : 
     195           4 :     const rtError_t rtErr = rtEventSynchronize(static_cast<rtEvent_t>(event));
     196           4 :     if (rtErr != RT_ERROR_NONE) {
     197           2 :         ACL_LOG_CALL_ERROR("wait event to be complete failed, runtime result = %d", static_cast<int32_t>(rtErr));
     198           2 :         return ACL_GET_ERRCODE_RTS(rtErr);
     199             :     }
     200           2 :     ACL_LOG_INFO("successfully execute aclrtSynchronizeEvent");
     201           2 :     return ACL_SUCCESS;
     202             : }
     203             : 
     204           4 : aclError aclrtSynchronizeEventWithTimeoutImpl(aclrtEvent event, int32_t timeout)
     205             : {
     206           4 :     ACL_LOG_INFO("start to execute aclrtSynchronizeEventWithTimeout, timeout = %dms", timeout);
     207           4 :     constexpr int32_t default_timeout = -1;
     208           4 :     if (timeout < default_timeout) {
     209           1 :         ACL_LOG_CALL_ERROR("the timeout of synchronize event is invalid");
     210           1 :         return ACL_ERROR_RT_PARAM_INVALID;
     211             :     }
     212           3 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(event);
     213             : 
     214           2 :     const rtError_t rtErr = rtEventSynchronizeWithTimeout(static_cast<rtEvent_t>(event), timeout);
     215           2 :     if (rtErr == ACL_ERROR_RT_EVENT_SYNC_TIMEOUT) {
     216           1 :         ACL_LOG_CALL_ERROR("synchronize event timeout, timeout = %dms", timeout);
     217           1 :         return ACL_ERROR_RT_EVENT_SYNC_TIMEOUT;
     218           1 :     } else if (rtErr != RT_ERROR_NONE) {
     219           0 :         ACL_LOG_CALL_ERROR("wait event to be complete failed, runtime result = %dms", static_cast<int32_t>(rtErr));
     220           0 :         return ACL_GET_ERRCODE_RTS(rtErr);
     221             :     }
     222           1 :     ACL_LOG_INFO("successfully execute aclrtSynchronizeEventWithTimeout");
     223           1 :     return ACL_SUCCESS;
     224             : }
     225             : 
     226          10 : aclError aclrtEventElapsedTimeImpl(float *ms, aclrtEvent startEvent, aclrtEvent endEvent)
     227             : {
     228          10 :     ACL_LOG_INFO("start to execute aclrtEventElapsedTime");
     229          10 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(ms);
     230           8 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(startEvent);
     231           6 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(endEvent);
     232             : 
     233           4 :     const rtError_t rtErr = rtEventElapsedTime(ms, startEvent, endEvent);
     234           4 :     if (rtErr != RT_ERROR_NONE) {
     235           2 :         ACL_LOG_CALL_ERROR("computes events elapsed time failed, runtime result = %d", static_cast<int32_t>(rtErr));
     236           2 :         return ACL_GET_ERRCODE_RTS(rtErr);
     237             :     }
     238           2 :     ACL_LOG_INFO("successfully execute aclrtEventElapsedTime");
     239           2 :     return ACL_SUCCESS;
     240             : }
     241             : 
     242           3 : aclError aclrtEventGetTimestampImpl(aclrtEvent event, uint64_t *timestamp)
     243             : {
     244           3 :     ACL_LOG_INFO("start to execute aclrtEventGetTimestamp");
     245           3 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(timestamp);
     246           2 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(event);
     247             : 
     248           1 :     ACL_REQUIRES_CALL_RTS_OK(rtEventGetTimeStamp(timestamp, event), rtEventGetTimeStamp);
     249             : 
     250           1 :     ACL_LOG_INFO("successfully execute aclrtEventGetTimestamp");
     251           1 :     return ACL_SUCCESS;
     252             : }
     253             : 
     254           4 : aclError aclrtSetOpWaitTimeoutImpl(uint32_t timeout)
     255             : {
     256           8 :     ACL_PROFILING_REG(acl::AclProfType::AclrtSetOpWaitTimeout);
     257           4 :     ACL_LOG_INFO("start to execute aclrtSetOpWaitTimeout, timeout = %us", timeout);
     258           4 :     ACL_REQUIRES_CALL_RTS_OK(rtSetOpWaitTimeOut(timeout), rtSetOpWaitTimeOut);
     259           2 :     ACL_LOG_INFO("successfully execute aclrtSetOpWaitTimeout, timeout = %us", timeout);
     260           2 :     return ACL_SUCCESS;
     261             : }
     262             : 
     263           2 : aclError aclrtSetOpExecuteTimeOutImpl(uint32_t timeout)
     264             : {
     265           4 :     ACL_PROFILING_REG(acl::AclProfType::AclrtSetOpExecuteTimeOut);
     266           2 :     ACL_LOG_INFO("start to execute aclrtSetOpExecuteTimeOut, timeout = %us", timeout);
     267             : 
     268           2 :     const rtError_t rtErr = rtSetOpExecuteTimeOut(timeout);
     269           2 :     if (rtErr != RT_ERROR_NONE) {
     270           1 :         ACL_LOG_CALL_ERROR("set op execute timeout failed, runtime result = %d", static_cast<int32_t>(rtErr));
     271           1 :         return ACL_GET_ERRCODE_RTS(rtErr);
     272             :     }
     273             : 
     274           1 :     ACL_LOG_INFO("successfully execute aclrtSetOpExecuteTimeOut, timeout = %us", timeout);
     275           1 :     return ACL_SUCCESS;
     276             : }
     277             : 
     278           2 : aclError aclrtSetOpExecuteTimeOutWithMsImpl(uint32_t timeout)
     279             : {
     280           4 :     ACL_PROFILING_REG(acl::AclProfType::AclrtSetOpExecuteTimeOutWithMs);
     281           2 :     ACL_LOG_INFO("start to execute aclrtSetOpExecuteTimeOutWithMs, timeout = %ums", timeout);
     282             : 
     283           2 :     const rtError_t rtErr = rtSetOpExecuteTimeOutWithMs(timeout);
     284           2 :     if (rtErr != RT_ERROR_NONE) {
     285           1 :         ACL_LOG_CALL_ERROR("set op execute timeout failed, runtime result = %d", static_cast<int32_t>(rtErr));
     286           1 :         return ACL_GET_ERRCODE_RTS(rtErr);
     287             :     }
     288             : 
     289           1 :     ACL_LOG_INFO("successfully execute aclrtSetOpExecuteTimeOutWithMs, timeout = %ums", timeout);
     290           1 :     return ACL_SUCCESS;
     291             : }
     292             : 
     293           2 : aclError aclrtSetOpExecuteTimeOutV2Impl(uint64_t timeout, uint64_t *actualTimeout)
     294             : {
     295           4 :     ACL_PROFILING_REG(acl::AclProfType::AclrtSetOpExecuteTimeOutV2);
     296           2 :     ACL_LOG_INFO("start to execute aclrtSetOpExecuteTimeOutV2, timeout = %zu us", timeout);
     297           2 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(actualTimeout);
     298           2 :     ACL_REQUIRES_CALL_RTS_OK(rtSetOpExecuteTimeOutV2(timeout, actualTimeout), rtSetOpExecuteTimeOutV2);
     299           1 :     ACL_LOG_INFO("successfully execute aclrtSetOpExecuteTimeOutV2, timeout = %zu us, actual timeout = %zu us", timeout,
     300             :                  *actualTimeout);
     301           1 :     return ACL_SUCCESS;
     302             : }
     303             : 
     304           2 : aclError aclrtGetOpTimeOutIntervalImpl(uint64_t *interval)
     305             : {
     306           4 :     ACL_PROFILING_REG(acl::AclProfType::AclrtGetOpTimeOutInterval);
     307           2 :     ACL_LOG_INFO("start to execute aclrtGetOpTimeOutIntervalImpl");
     308           2 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(interval);
     309           2 :     ACL_REQUIRES_CALL_RTS_OK(rtGetOpTimeOutInterval(interval), rtGetOpTimeOutInterval);
     310           1 :     ACL_LOG_INFO("successfully execute aclrtGetOpTimeOutIntervalImpl, interval = %zu us", *interval);
     311           1 :     return ACL_SUCCESS;
     312             : }
     313             : 
     314           6 : aclError aclrtGetMemUceInfoImpl(int32_t deviceId, aclrtMemUceInfo *memUceInfoArray,
     315             :                                 size_t arraySize, size_t *retSize)
     316             : {
     317          12 :     ACL_PROFILING_REG(acl::AclProfType::AclrtGetMemUceInfo);
     318           6 :     ACL_LOG_INFO("start to execute aclrtGetMemUceInfo on device %d, arraySize %zu", deviceId, arraySize);
     319           6 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(memUceInfoArray);
     320           5 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(retSize);
     321             : 
     322           4 :     rtMemUceInfo rtUceInfo = {};
     323           4 :     ACL_REQUIRES_CALL_RTS_OK(rtGetMemUceInfo(deviceId, &rtUceInfo), rtGetMemUceInfo);
     324           3 :     if (arraySize < rtUceInfo.count) {
     325           1 :         ACL_LOG_ERROR("failed to execute aclrtGetMemUceInfo, because arraySize %zu is less than the required size %u",
     326             :                       arraySize, rtUceInfo.count);
     327           1 :         return ACL_ERROR_INVALID_PARAM;
     328             :     }
     329             : 
     330           2 :     size_t realSize = std::min(rtUceInfo.count, RT_MAX_RECORD_PA_NUM_PER_DEV);
     331          22 :     for (size_t i = 0; i < realSize; ++i) {
     332          20 :         memUceInfoArray[i].addr = reinterpret_cast<void *>(rtUceInfo.repairAddr[i].ptr);
     333          20 :         memUceInfoArray[i].len = rtUceInfo.repairAddr[i].len;
     334          20 :         (void)memset_s(memUceInfoArray[i].reserved, sizeof(memUceInfoArray[i].reserved),
     335             :                        0, sizeof(memUceInfoArray[i].reserved));
     336             :     }
     337           2 :     *retSize = realSize;
     338             : 
     339           2 :     ACL_LOG_INFO("successfully execute aclrtGetMemUceInfo on device %d, arraySize %zu, retSize %zu,",
     340             :                  deviceId, arraySize, *retSize);
     341           2 :     return ACL_SUCCESS;
     342             : }
     343             : 
     344           5 : aclError aclrtMemUceRepairImpl(int32_t deviceId, aclrtMemUceInfo *memUceInfoArray, size_t arraySize)
     345             : {
     346          10 :     ACL_PROFILING_REG(acl::AclProfType::AclrtMemUceRepair);
     347           5 :     ACL_LOG_INFO("start to execute aclrtMemUceRepair on device %d, arraySize %zu", deviceId, arraySize);
     348           5 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(memUceInfoArray);
     349             : 
     350           4 :     if (arraySize > RT_MAX_RECORD_PA_NUM_PER_DEV) {
     351           1 :         ACL_LOG_ERROR("failed to execute aclrtMemUceRepair, because arraySize %zu is exceed max size %d",
     352             :                       arraySize, RT_MAX_RECORD_PA_NUM_PER_DEV);
     353           1 :         return ACL_ERROR_INVALID_PARAM;
     354             :     }
     355             : 
     356             :     //reserved value check, should be fill with zero
     357           3 :     size_t reservedZeroValue[UCE_INFO_RESERVED_SIZE] = {0};
     358          19 :     for (size_t i = 0; i < arraySize; ++i) {
     359          17 :         if (memcmp(memUceInfoArray[i].reserved, reservedZeroValue, UCE_INFO_RESERVED_SIZE)) {
     360           1 :             ACL_LOG_ERROR("failed to execute aclrtMemUceRepair with mismatched version, "
     361             :                           "pls set valid value only for ptr and len ");
     362           1 :             return ACL_ERROR_INVALID_PARAM;
     363             :         }
     364             :     }
     365             : 
     366           2 :     rtMemUceInfo rtUceInfo = {};
     367           2 :     rtUceInfo.devid = deviceId;
     368           2 :     rtUceInfo.count = arraySize;
     369          18 :     for (size_t i = 0; i < arraySize; ++i) {
     370          16 :         rtUceInfo.repairAddr[i].ptr = reinterpret_cast<uint64_t>(memUceInfoArray[i].addr);
     371          16 :         rtUceInfo.repairAddr[i].len = memUceInfoArray[i].len;
     372             :     }
     373             : 
     374           2 :     const rtError_t rtErr = rtMemUceRepair(deviceId, &rtUceInfo);
     375           2 :     if (rtErr != RT_ERROR_NONE) {
     376           1 :         ACL_LOG_CALL_ERROR("rtMemUceRepair failed, device id is runtime result = %d", static_cast<int32_t>(rtErr));
     377           1 :         return ACL_GET_ERRCODE_RTS(rtErr);
     378             :     }
     379           1 :     return ACL_SUCCESS;
     380             : }
     381             : 
     382           4 : aclError aclrtGetEventIdImpl(aclrtEvent event, uint32_t *eventId)
     383             : {
     384           8 :     ACL_PROFILING_REG(acl::AclProfType::AclrtGetEventId);
     385           4 :     ACL_LOG_INFO("start to execute aclrtGetEventId");
     386           4 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(event);
     387           3 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(eventId);
     388             : 
     389           2 :     const rtError_t rtErr = rtsEventGetId(static_cast<rtEvent_t>(event), eventId);
     390           2 :     if (rtErr != RT_ERROR_NONE) {
     391           1 :         ACL_LOG_CALL_ERROR("call rtsEventGetId failed, runtime result = %d", static_cast<int32_t>(rtErr));
     392           1 :         return ACL_GET_ERRCODE_RTS(rtErr);
     393             :     }
     394             : 
     395           1 :     ACL_LOG_INFO("successfully execute aclrtGetEventId");
     396           1 :     return ACL_SUCCESS;
     397             : }
     398             : 
     399           3 : aclError aclrtGetEventAvailNumImpl(uint32_t *eventCount)
     400             : {
     401           6 :     ACL_PROFILING_REG(acl::AclProfType::AclrtGetEventAvailNum);
     402           3 :     ACL_LOG_INFO("start to execute aclrtGetEventAvailNum");
     403           3 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(eventCount);
     404             : 
     405           2 :     const rtError_t rtErr = rtsEventGetAvailNum(eventCount);
     406           2 :     if (rtErr != RT_ERROR_NONE) {
     407           1 :         ACL_LOG_CALL_ERROR("call rtsEventGetAvailNum failed, runtime result = %d", static_cast<int32_t>(rtErr));
     408           1 :         return ACL_GET_ERRCODE_RTS(rtErr);
     409             :     }
     410             : 
     411           1 :     ACL_LOG_INFO("successfully execute aclrtGetEventAvailNum");
     412           1 :     return ACL_SUCCESS;
     413             : }
     414             : 
     415             : // Implementation of querying detailed information of NPU faults
     416           1 : aclError aclrtGetErrorVerboseImpl(int32_t deviceId, aclrtErrorInfo *errorInfo)
     417             : {
     418           2 :     ACL_PROFILING_REG(acl::AclProfType::AclrtGetErrorVerbose);
     419           1 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(errorInfo);
     420             : 
     421           1 :     ACL_LOG_INFO("start to execute aclrtGetErrorVerbose with deviceId %d", deviceId);
     422             : 
     423             :     // Type conversion adaptation
     424           1 :     uint32_t rtsDeviceId = static_cast<uint32_t>(deviceId);
     425           1 :     rtErrorInfo *rtsErrorInfo = reinterpret_cast<rtErrorInfo*>(errorInfo);
     426             : 
     427             :     // Call RTS interface
     428           1 :     ACL_REQUIRES_CALL_RTS_OK(rtsGetErrorVerbose(rtsDeviceId, rtsErrorInfo), rtsGetErrorVerbose);
     429           1 :     ACL_LOG_INFO("successfully execute aclrtGetErrorVerbose");
     430           1 :     return ACL_SUCCESS;
     431             : }
     432             : 
     433             : // Repair NPU malfunction implementation
     434           1 : aclError aclrtRepairErrorImpl(int32_t deviceId, const aclrtErrorInfo *errorInfo)
     435             : {
     436           2 :     ACL_PROFILING_REG(acl::AclProfType::AclrtRepairError);
     437           1 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(errorInfo);
     438           1 :     ACL_LOG_INFO("start to execute aclrtRepairError with deviceId %d and errorType %d", deviceId, errorInfo->errorType);
     439             : 
     440             :     // Type conversion adaptation
     441           1 :     uint32_t rtsDeviceId = static_cast<uint32_t>(deviceId);
     442           1 :     const rtErrorInfo *rtsErrorInfo = reinterpret_cast<const rtErrorInfo*>(errorInfo);
     443             : 
     444             :     // Call RTS interface
     445           1 :     ACL_REQUIRES_CALL_RTS_OK(rtsRepairError(rtsDeviceId, rtsErrorInfo), rtsRepairError);
     446           1 :     ACL_LOG_INFO("successfully execute aclrtRepairError");
     447           1 :     return ACL_SUCCESS;
     448             : }
     449             : 
     450           4 : aclError aclrtStreamWaitEventWithTimeoutImpl(aclrtStream stream, aclrtEvent event, int32_t timeout)
     451             : {
     452           8 :     ACL_PROFILING_REG(acl::AclProfType::AclrtStreamWaitEventWithTimeout);
     453           4 :     ACL_LOG_INFO("start to execute aclrtStreamWaitEventWithTimeout, timeout is %d", timeout);
     454           4 :     if (timeout <= 0) {
     455           1 :         ACL_LOG_CALL_ERROR("the range of timeout is invalid");
     456           1 :         return ACL_ERROR_RT_PARAM_INVALID;
     457             :     }
     458             : 
     459           3 :     const rtError_t rtErr = rtsEventWait(static_cast<rtStream_t>(stream), static_cast<rtEvent_t>(event), timeout);
     460           3 :     if (rtErr != RT_ERROR_NONE) {
     461           1 :         ACL_LOG_CALL_ERROR("call aclrtStreamWaitEventWithTimeout failed, runtime result = %d", static_cast<int32_t>(rtErr));
     462           1 :         return ACL_GET_ERRCODE_RTS(rtErr);
     463             :     }
     464           2 :     ACL_LOG_INFO("successfully execute aclrtStreamWaitEventWithTimeout");
     465           2 :     return ACL_SUCCESS;
     466             : }
     467             : 
     468           3 : aclError aclrtIpcGetEventHandleImpl(aclrtEvent event, aclrtIpcEventHandle *handle)
     469             : {
     470           6 :     ACL_PROFILING_REG(acl::AclProfType::AclrtIpcGetEventHandle);
     471           3 :     ACL_LOG_INFO("start to execute aclrtIpcGetEventHandle.");
     472           3 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(handle);
     473           3 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(event);
     474           3 :     const rtError_t rtErr = rtIpcGetEventHandle(static_cast<rtEvent_t>(event), reinterpret_cast<rtIpcEventHandle_t*>(handle));
     475           3 :     if (rtErr != RT_ERROR_NONE) {
     476           2 :         if (rtErr == ACL_ERROR_RT_FEATURE_NOT_SUPPORT) {
     477           1 :             ACL_LOG_WARN("rtIpcGetEventHandle unsupport, runtime result = %d", static_cast<int32_t>(rtErr));
     478             :         } else {
     479           1 :             ACL_LOG_CALL_ERROR("call rtIpcGetEventHandle Failed, runtime result = %d", static_cast<int32_t>(rtErr));
     480             :         }
     481           2 :         return ACL_GET_ERRCODE_RTS(rtErr);
     482             :     }
     483           1 :     ACL_LOG_INFO("successfully execute aclrtIpcGetEventHandle.");
     484           1 :     return ACL_SUCCESS;
     485             : }
     486             : 
     487           3 : aclError aclrtIpcOpenEventHandleImpl(aclrtIpcEventHandle handle, aclrtEvent *event)
     488             : {
     489           6 :     ACL_PROFILING_REG(acl::AclProfType::AclrtIpcOpenEventHandle);
     490           3 :     ACL_LOG_INFO("start to execute aclrtIpcOpenEventHandle.");
     491           3 :     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(event);
     492           3 :     rtEvent_t rtEvent = nullptr;
     493           3 :     const rtError_t rtErr = rtIpcOpenEventHandle(*(rtIpcEventHandle_t*)&handle, &rtEvent);
     494           3 :     if (rtErr != RT_ERROR_NONE) {
     495           2 :         if (rtErr == ACL_ERROR_RT_FEATURE_NOT_SUPPORT) {
     496           1 :             ACL_LOG_WARN("rtIpcOpenEventHandle unsupport, runtime result = %d", static_cast<int32_t>(rtErr));
     497             :         } else {
     498           1 :             ACL_LOG_CALL_ERROR("call rtIpcOpenEventHandle Failed, runtime result = %d", static_cast<int32_t>(rtErr));
     499             :         }
     500           2 :         return ACL_GET_ERRCODE_RTS(rtErr);
     501             :     }
     502           1 :     *event = static_cast<aclrtEvent>(rtEvent);
     503           1 :     ACL_LOG_INFO("successfully execute aclrtIpcOpenEventHandle.");
     504           1 :     return ACL_SUCCESS;
     505             : }