runtime_3379/src/runtime/api/api_c_device.cc-代码预览-runtime_3379:基于 CANN 生态的昇腾 NPU 运行时与维测组件项目

cann-robot【fix】: 修复GetDeviceInfo传入不支持的info_type时，上报EE1001的errMsg
/**

 * Copyright (c) 2025 Huawei Technologies Co., Ltd.

 * This program is free software, you can redistribute it and/or modify it under the terms and conditions of

 * CANN Open Software License Agreement Version 2.0 (the "License").

 * Please refer to the License for details. You may not use this file except in compliance with the License.

 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,

 * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.

 * See LICENSE in the root of the software repository for the full text of the License.

 */



#include "api_c.h"

#include "api.hpp"

#include "api_handle_guard.h"

#include "device_enum_desc.hpp"

#include "errcode_manage.hpp"

#include "error_code.h"

#include "driver/ascend_hal.h"

#include "osal.hpp"

#include "prof_map_ge_model_device.hpp"

#include "runtime_keeper.h"

#include "global_state_manager.hpp"



using namespace cce::runtime;



#ifdef __cplusplus

extern "C" {

#endif // __cplusplus



VISIBILITY_DEFAULT

rtError_t rtOpenNetService(const rtNetServiceOpenArgs* args)

{

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const rtError_t error = apiInstance->OpenNetService(args);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtCloseNetService()

{

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const rtError_t error = apiInstance->CloseNetService();

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtGetDeviceIDs(uint32_t* devices, uint32_t len)

{

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const rtError_t error = apiInstance->GetDeviceIDs(devices, len);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtsSetDevice(int32_t devId) { return rtSetDevice(devId); }



VISIBILITY_DEFAULT

rtError_t rtSetDevice(int32_t devId)

{

    GLOBAL_STATE_WAIT_IF_LOCKED();

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const rtError_t error = apiInstance->SetDevice(devId);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);



    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtGetDevice(int32_t* devId)

{

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const rtError_t error = apiInstance->GetDevice(devId);

    COND_RETURN_WITH_NOLOG(error == RT_ERROR_CONTEXT_NULL, ACL_ERROR_RT_CONTEXT_NULL); // special state

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtsGetDevice(int32_t* devId) { return rtGetDevice(devId); }



VISIBILITY_DEFAULT

rtError_t rtGetVisibleDeviceIdByLogicDeviceId(const int32_t logicDeviceId, int32_t* const visibleDeviceId)

{

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const rtError_t error = apiInstance->GetVisibleDeviceIdByLogicDeviceId(logicDeviceId, visibleDeviceId);

    COND_RETURN_WITH_NOLOG(error == RT_ERROR_CONTEXT_NULL, ACL_ERROR_RT_CONTEXT_NULL); // special state

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtDeviceReset(int32_t devId)

{

    GLOBAL_STATE_WAIT_IF_LOCKED();

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const rtError_t error = apiInstance->DeviceReset(devId);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtsResetDevice(int32_t devId) { return rtDeviceReset(devId); }



VISIBILITY_DEFAULT

rtError_t rtsDeviceResetForce(int32_t devId) { return rtDeviceResetForce(devId); }



VISIBILITY_DEFAULT

rtError_t rtsGetRunMode(rtRunMode* runMode) { return rtGetRunMode(runMode); }



VISIBILITY_DEFAULT

rtError_t rtsGetDeviceUtilizations(const int32_t devId, const rtTypeUtil_t kind, uint8_t* const util)

{

    return rtGetAllUtilizations(devId, kind, util);

}



VISIBILITY_DEFAULT

rtError_t rtsGetSocVersion(char_t* ver, const uint32_t maxLen) { return rtGetSocVersion(ver, maxLen); }



VISIBILITY_DEFAULT

rtError_t rtsSetOpWaitTimeOut(uint32_t timeout) { return rtSetOpWaitTimeOut(timeout); }



VISIBILITY_DEFAULT

rtError_t rtDeviceSetLimit(int32_t devId, rtLimitType_t type, uint32_t val)

{

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const rtError_t error = apiInstance->DeviceSetLimit(devId, type, val);

    COND_RETURN_WITH_NOLOG(error == RT_ERROR_FEATURE_NOT_SUPPORT, ACL_ERROR_RT_FEATURE_NOT_SUPPORT);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtDeviceGetLimit(rtLimitType_t type, uint32_t* val)

{

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const rtError_t error = apiInstance->DeviceGetLimit(type, val);

    COND_RETURN_WITH_NOLOG(error == RT_ERROR_FEATURE_NOT_SUPPORT, ACL_ERROR_RT_FEATURE_NOT_SUPPORT);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtDeviceSynchronize(void)

{

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const rtError_t error = apiInstance->DeviceSynchronize();

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtDeviceSynchronizeWithTimeout(int32_t timeout)

{

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const rtError_t error = apiInstance->DeviceSynchronize(timeout);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtDeviceGetStreamPriorityRange(int32_t* leastPriority, int32_t* greatestPriority)

{

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const rtError_t error = apiInstance->DeviceGetStreamPriorityRange(leastPriority, greatestPriority);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtsDeviceGetStreamPriorityRange(int32_t* leastPriority, int32_t* greatestPriority)

{

    return rtDeviceGetStreamPriorityRange(leastPriority, greatestPriority);

}



VISIBILITY_DEFAULT

rtError_t rtGetDeviceInfo(uint32_t deviceId, int32_t moduleType, int32_t infoType, int64_t* val)

{

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const rtError_t error = apiInstance->GetDeviceInfo(deviceId, moduleType, infoType, val);

    COND_RETURN_WITH_NOLOG(error == RT_ERROR_FEATURE_NOT_SUPPORT, ACL_ERROR_RT_FEATURE_NOT_SUPPORT);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtGetPhyDeviceInfo(uint32_t phyId, int32_t moduleType, int32_t infoType, int64_t* val)

{

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const rtError_t error = apiInstance->GetPhyDeviceInfo(phyId, moduleType, infoType, val);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtsSetTsDevice(uint32_t tsId) { return rtSetTSDevice(tsId); }



VISIBILITY_DEFAULT

rtError_t rtSetTSDevice(uint32_t tsId)

{

    DevProperties prop;

    const Runtime* const rtInstance = Runtime::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(rtInstance);

    rtError_t ret = GET_DEV_PROPERTIES(rtInstance->GetChipType(), prop);

    ERROR_RETURN_WITH_EXT_ERRCODE(ret);

    if (prop.tsCount == 1U) { // single ts

        return ACL_RT_SUCCESS;

    }



    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const rtError_t error = apiInstance->DeviceSetTsId(tsId);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtGetTSDevice(uint32_t* tsId)

{

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const rtError_t error = apiInstance->DeviceGetTsId(tsId);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtGetDeviceIdByGeModelIdx(uint32_t geModelIdx, uint32_t* deviceId)

{

    RT_LOG(RT_LOG_DEBUG, "geModelIdx:%u", geModelIdx);

    PARAM_NULL_RETURN_ERROR_WITH_EXT_ERRCODE(deviceId, RT_ERROR_INVALID_VALUE);



    uint32_t drvDeviceId;

    rtError_t error = ProfMapGeModelDevice::Instance().GetDeviceIdByGeModelIdx(geModelIdx, &drvDeviceId);

    if (error != RT_ERROR_NONE) {

        RT_LOG_OUTER_MSG_IMPL(

            ErrorCode::EE1011, __func__, std::to_string(geModelIdx), "geModelIdx",

            "The device of geModelIdx does not exist");

        ERROR_RETURN_WITH_EXT_ERRCODE(error);

    }



    int32_t userDeviceId;

    error = rtGetUserDevIdByLogicDevId(static_cast<int32_t>(drvDeviceId), &userDeviceId);

    COND_RETURN_ERROR_MSG_INNER(

        error != RT_ERROR_NONE, error, "Failed to get userDeviceId by drv devId:%u, retCode=%#x.", drvDeviceId,

        static_cast<uint32_t>(error));

    *deviceId = static_cast<uint32_t>(userDeviceId);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtSetDeviceEx(int32_t devId)

{

    GLOBAL_STATE_WAIT_IF_LOCKED();

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const rtError_t error = apiInstance->SetDevice(devId);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtDeviceResetEx(int32_t devId)

{

    GLOBAL_STATE_WAIT_IF_LOCKED();

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const rtError_t error = apiInstance->DeviceReset(devId);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtDeviceGetBareTgid(uint32_t* pid)

{

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const rtError_t error = apiInstance->DeviceGetBareTgid(pid);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtsDeviceGetBareTgid(uint32_t* pid) { return rtDeviceGetBareTgid(pid); }



VISIBILITY_DEFAULT

rtError_t rtDeviceResetWithoutTsd(int32_t devId)

{

    GLOBAL_STATE_WAIT_IF_LOCKED();

    Api* const apiInstance = Api::Instance(API_ENV_FLAGS_NO_TSD);

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const rtError_t error = apiInstance->DeviceReset(devId);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtGetDeviceCapability(int32_t deviceId, int32_t moduleType, int32_t featureType, int32_t* val)

{

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const rtError_t error = apiInstance->GetDeviceCapability(deviceId, moduleType, featureType, val);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtsDeviceGetCapability(int32_t deviceId, int32_t devFeatureType, int32_t* val)

{

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    rtError_t error = RT_ERROR_NONE;

    COND_RETURN_EXT_ERRCODE_AND_MSG_OUTER_WITH_PARAM_NAME(

        (devFeatureType >= static_cast<int32_t>(RT_DEV_FEATURE_MAX)) || (devFeatureType < 0), RT_ERROR_INVALID_VALUE,

        DevFeatureTypeToString(devFeatureType), "devFeatureType", "[0, " + std::to_string(RT_DEV_FEATURE_MAX) + ")");



    if (devFeatureType == static_cast<int32_t>(RT_FEATURE_TSCPU_TASK_UPDATE_SUPPORT_AIC_AIV)) {

        error = apiInstance->GetDeviceCapability(

            deviceId, static_cast<int32_t>(RT_MODULE_TYPE_TSCPU), static_cast<int32_t>(FEATURE_TYPE_MODEL_TASK_UPDATE),

            val);

        ERROR_RETURN_WITH_EXT_ERRCODE(error);

        switch (*val) {

            case static_cast<int32_t>(RT_DEV_CAP_SUPPORT):

                *val = static_cast<int32_t>(FEATURE_SUPPORT);

                break;

            case static_cast<int32_t>(RT_DEV_CAP_NOT_SUPPORT):

                *val = static_cast<int32_t>(FEATURE_NOT_SUPPORT);

                break;

            default:

                *val = static_cast<int32_t>(FEATURE_NOT_SUPPORT);

                break;

        }

    } else if (devFeatureType == static_cast<int32_t>(RT_FEATURE_SYSTEM_MEMQ_EVENT_CROSS_DEV)) {

        error = apiInstance->GetDeviceCapability(

            deviceId, static_cast<int32_t>(RT_MODULE_TYPE_SYSTEM),

            static_cast<int32_t>(FEATURE_TYPE_MEMQ_EVENT_CROSS_DEV), val);

        ERROR_RETURN_WITH_EXT_ERRCODE(error);

    } else if (devFeatureType == static_cast<int32_t>(RT_FEATURE_AICPU_SCHEDULE_TYPE)) {

        error = apiInstance->GetDeviceCapability(

            deviceId, static_cast<int32_t>(MODULE_TYPE_AICPU), static_cast<int32_t>(FEATURE_TYPE_SCHE), val);

        ERROR_RETURN_WITH_EXT_ERRCODE(error);

    } else if (devFeatureType == static_cast<int32_t>(RT_FEATURE_SYSTEM_TASKID_BIT_WIDTH)) {

        error = apiInstance->GetDeviceCapability(

            deviceId, static_cast<int32_t>(RT_MODULE_TYPE_SYSTEM), devFeatureType, val);

        ERROR_RETURN_WITH_EXT_ERRCODE(error);

    } else {

        RT_LOG_OUTER_MSG_WITH_FUNC(

            ErrorCode::EE1003, DevFeatureTypeToString(devFeatureType), "devFeatureType",

            "[" + std::to_string(RT_FEATURE_TSCPU_TASK_UPDATE_SUPPORT_AIC_AIV) + ", " +

                std::to_string(RT_DEV_FEATURE_MAX) + ")");

        return ACL_ERROR_RT_PARAM_INVALID;

    }

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtGetDevMsg(rtGetDevMsgType_t getMsgType, rtGetMsgCallback callback)

{

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const rtError_t error = apiInstance->GetDevMsg(getMsgType, callback);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

RTS_API rtError_t rtGetDeviceSatMode(rtFloatOverflowMode_t* floatOverflowMode)

{

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const rtError_t ret = apiInstance->GetDeviceSatMode(floatOverflowMode);

    ERROR_RETURN_WITH_EXT_ERRCODE(ret);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

RTS_API rtError_t rtGetDeviceSatModeForStream(rtStream_t stm, rtFloatOverflowMode_t* floatOverflowMode)

{

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    RT_VALIDATE_AND_UNWRAP_OBJECT(stm, Stream, targetStm);

    const rtError_t ret = apiInstance->GetDeviceSatModeForStream(targetStm, floatOverflowMode);

    ERROR_RETURN_WITH_EXT_ERRCODE(ret);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

RTS_API rtError_t rtDeviceStatusQuery(const uint32_t devId, rtDeviceStatus* deviceStatus)

{

    Runtime* rtInstance = (IsRuntimeKeeperExiting() ? nullptr : Runtime::Instance());

    NULL_RETURN_WARNING_WITH_EXT_ERRCODE(rtInstance, RT_ERROR_INSTANCE_NULL);

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_WARNING_WITH_EXT_ERRCODE(apiInstance, RT_ERROR_API_NULL);

    const rtError_t error = apiInstance->DeviceStatusQuery(devId, deviceStatus);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);



    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtDeviceTaskAbort(int32_t devId, uint32_t timeout)

{

    GLOBAL_STATE_WAIT_IF_LOCKED();

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const rtError_t error = apiInstance->DeviceTaskAbort(devId, timeout);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtSetDeviceFailureMode(uint64_t failureMode)

{

    const Runtime* const rtInstance = Runtime::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(rtInstance);

    if (!IS_SUPPORT_CHIP_FEATURE(

            rtInstance->GetChipType(), RtOptionalFeatureType::RT_FEATURE_DEVICE_FAILURE_MODE_SET)) {

        RT_LOG_OUTER_MSG_WITH_FUNC(ErrorCode::EE1005);

        return GetRtExtErrCodeAndSetGlobalErr(RT_ERROR_FEATURE_NOT_SUPPORT);

    }

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const rtError_t error = apiInstance->SetDeviceFailureMode(failureMode);

    COND_RETURN_WITH_NOLOG(error == RT_ERROR_FEATURE_NOT_SUPPORT, ACL_ERROR_RT_FEATURE_NOT_SUPPORT);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtGetDeviceStatus(const int32_t devId, rtDevStatus_t* const status)

{

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);



    const rtError_t error = apiInstance->GetDeviceStatus(devId, status);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtHdcServerCreate(const int32_t devId, const rtHdcServiceType_t type, rtHdcServer_t* const server)

{

    GLOBAL_STATE_WAIT_IF_LOCKED();

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);



    const rtError_t error = apiInstance->HdcServerCreate(devId, type, server);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtHdcServerDestroy(rtHdcServer_t const server)

{

    GLOBAL_STATE_WAIT_IF_LOCKED();

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);



    const rtError_t error = apiInstance->HdcServerDestroy(server);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtHdcSessionConnect(

    const int32_t peerNode, const int32_t peerDevId, rtHdcClient_t const client, rtHdcSession_t* const session)

{

    GLOBAL_STATE_WAIT_IF_LOCKED();

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);



    const rtError_t error = apiInstance->HdcSessionConnect(peerNode, peerDevId, client, session);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtHdcSessionClose(rtHdcSession_t const session)

{

    GLOBAL_STATE_WAIT_IF_LOCKED();

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);



    const rtError_t error = apiInstance->HdcSessionClose(session);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtGetHostCpuDevId(int32_t* const devId)

{

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);



    const rtError_t error = apiInstance->GetHostCpuDevId(devId);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtDebugSetDumpMode(const uint64_t mode)

{

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const rtError_t error = apiInstance->DebugSetDumpMode(mode);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtDebugGetStalledCore(rtDbgCoreInfo_t* const coreInfo)

{

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const rtError_t error = apiInstance->DebugGetStalledCore(coreInfo);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtDebugReadAICore(rtDebugMemoryParam_t* const param)

{

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const rtError_t error = apiInstance->DebugReadAICore(param);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtGetBinBuffer(const rtBinHandle binHandle, const rtBinBufferType_t type, void** bin, uint32_t* binSize)

{

    Api* apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    RT_VALIDATE_AND_UNWRAP_OBJECT_WITH_VALIDATOR(binHandle, Program, realProgram, ValidateProgramHandleForApi);

    const rtError_t error = apiInstance->GetBinBuffer(RtPtrToPtr<rtBinHandle>(realProgram), type, bin, binSize);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtGetStackBuffer(

    const rtBinHandle binHandle, uint32_t deviceId, const uint32_t stackType, const uint32_t coreType,

    const uint32_t coreId, const void** stack, uint32_t* stackSize)

{

    Api* apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    RT_VALIDATE_AND_UNWRAP_OBJECT_WITH_VALIDATOR(binHandle, Program, realProgram, ValidateProgramHandleForApi);

    const rtError_t error = apiInstance->GetStackBuffer(

        RtPtrToPtr<rtBinHandle>(realProgram), deviceId, stackType, coreType, coreId, stack, stackSize);

    if (error == RT_ERROR_FEATURE_NOT_SUPPORT) {

        return GetRtExtErrCodeAndSetGlobalErr(error);

    }

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtsDeviceStatusQuery(const uint32_t devId, rtDeviceStatus* deviceStatus)

{

    return rtDeviceStatusQuery(devId, deviceStatus);

}



VISIBILITY_DEFAULT

rtError_t rtSetDefaultDeviceId(const int32_t deviceId)

{

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const rtError_t error = apiInstance->SetDefaultDeviceId(deviceId);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtsSetDefaultDeviceId(const int32_t deviceId) { return rtSetDefaultDeviceId(deviceId); }



VISIBILITY_DEFAULT

RTS_API rtError_t rtsSetSysParamOpt(const rtSysParamOpt configOpt, const int64_t configVal)

{

    return rtSetSysParamOpt(configOpt, configVal);

}



VISIBILITY_DEFAULT

rtError_t rtsDeviceSynchronize(int32_t timeout) { return rtDeviceSynchronizeWithTimeout(timeout); }



VISIBILITY_DEFAULT

rtError_t rtsDeviceTaskAbort(int32_t devId, uint32_t timeout) { return rtDeviceTaskAbort(devId, timeout); }



VISIBILITY_DEFAULT

rtError_t rtsSetOpExecuteTimeOut(uint32_t timeout) { return rtSetOpExecuteTimeOut(timeout); }



VISIBILITY_DEFAULT

rtError_t rtsGetOpExecuteTimeOut(uint32_t* const timeout) { return rtGetOpExecuteTimeOut(timeout); }



VISIBILITY_DEFAULT

rtError_t rtsSetOpExecuteTimeOutWithMs(uint32_t timeout) { return rtSetOpExecuteTimeOutWithMs(timeout); }



VISIBILITY_DEFAULT

rtError_t rtsGetSysParamOpt(const rtSysParamOpt configOpt, int64_t* const configVal)

{

    return rtGetSysParamOpt(configOpt, configVal);

}



VISIBILITY_DEFAULT

rtError_t rtsGetErrorVerbose(const uint32_t deviceId, rtErrorInfo* const errorInfo)

{

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const Runtime* const rtInstance = Runtime::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(rtInstance);

    if (!IS_SUPPORT_CHIP_FEATURE(rtInstance->GetChipType(), RtOptionalFeatureType::RT_FEATURE_DFX_ERR_GET_AND_REPAIR)) {

        RT_LOG(

            RT_LOG_WARNING, "Chip type(%d) does not support rtsGetErrorVerbose api.",

            static_cast<int32_t>(rtInstance->GetChipType()));

        return GetRtExtErrCodeAndSetGlobalErr(RT_ERROR_FEATURE_NOT_SUPPORT);

    }

    const rtError_t error = apiInstance->GetErrorVerbose(deviceId, errorInfo);

    COND_RETURN_WITH_NOLOG(error == RT_ERROR_FEATURE_NOT_SUPPORT, ACL_ERROR_RT_FEATURE_NOT_SUPPORT);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtsRepairError(const uint32_t deviceId, const rtErrorInfo* const errorInfo)

{

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const Runtime* const rtInstance = Runtime::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(rtInstance);

    if (!IS_SUPPORT_CHIP_FEATURE(rtInstance->GetChipType(), RtOptionalFeatureType::RT_FEATURE_DFX_ERR_GET_AND_REPAIR)) {

        RT_LOG(

            RT_LOG_WARNING, "Chip type(%d) does not support rtsRepairError api.",

            static_cast<int32_t>(rtInstance->GetChipType()));

        return GetRtExtErrCodeAndSetGlobalErr(RT_ERROR_FEATURE_NOT_SUPPORT);

    }

    const rtError_t error = apiInstance->RepairError(deviceId, errorInfo);

    COND_RETURN_WITH_NOLOG(error == RT_ERROR_FEATURE_NOT_SUPPORT, ACL_ERROR_RT_FEATURE_NOT_SUPPORT);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtsDebugSetDumpMode(const uint64_t mode) { return rtDebugSetDumpMode(mode); }



VISIBILITY_DEFAULT

rtError_t rtsDebugGetStalledCore(rtDbgCoreInfo_t* const coreInfo) { return rtDebugGetStalledCore(coreInfo); }



VISIBILITY_DEFAULT

rtError_t rtsBinaryGetDevAddress(const rtBinHandle binHandle, void** bin, uint32_t* binSize)

{

    return rtGetBinBuffer(binHandle, RT_BIN_DEVICE_ADDR, bin, binSize);

}



VISIBILITY_DEFAULT

rtError_t rtsDebugReadAICore(rtDebugMemoryParam* const param)

{

    rtDebugMemoryParam_t debugParam = {};

    debugParam.coreId = param->coreId;

    debugParam.reserve = param->reserve;

    debugParam.coreType = static_cast<uint32_t>(param->coreType);

    debugParam.debugMemType = static_cast<rtDebugMemoryType_t>(static_cast<uint16_t>(param->debugMemType));

    debugParam.elementSize = param->elementSize;

    debugParam.reserved = param->reserved;

    debugParam.srcAddr = param->srcAddr;

    debugParam.dstAddr = param->dstAddr;

    debugParam.memLen = param->memLen;

    return rtDebugReadAICore(&debugParam);

}



VISIBILITY_DEFAULT

rtError_t rtSetDeviceWithFlags(int32_t deviceId, uint64_t flags)

{

    GLOBAL_STATE_WAIT_IF_LOCKED();

    rtError_t error;

    if (flags == RT_DEVICE_FLAG_DEFAULT) {

        Api* const apiInstance = Api::Instance();

        NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

        error = apiInstance->SetDevice(deviceId);

    } else if (flags == RT_DEVICE_FLAG_NOT_START_CPU_SCHED) {

        Api* const apiInstanceNoTSD = Api::Instance(API_ENV_FLAGS_NO_TSD);

        NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstanceNoTSD);

        error = apiInstanceNoTSD->SetDevice(deviceId);

    } else {

        RT_LOG_OUTER_MSG_INVALID_PARAM(flags, "RT_DEVICE_FLAG_DEFAULT or RT_DEVICE_FLAG_NOT_START_CPU_SCHED");

        error = RT_ERROR_INVALID_VALUE;

    }

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtDeviceGetCcMode(int32_t deviceId, int32_t* mode)

{

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const rtError_t error = apiInstance->DeviceGetCcMode(deviceId, mode);

    COND_RETURN_WITH_NOLOG(error == RT_ERROR_FEATURE_NOT_SUPPORT, ACL_ERROR_RT_FEATURE_NOT_SUPPORT);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



VISIBILITY_DEFAULT

rtError_t rtsDeviceGetInfo(uint32_t deviceId, rtDevAttr attr, int64_t* val)

{

    Api* const apiInstance = Api::Instance();

    NULL_RETURN_ERROR_WITH_EXT_ERRCODE(apiInstance);

    const rtError_t error = apiInstance->GetDeviceInfoByAttr(deviceId, attr, val);

    COND_RETURN_WITH_NOLOG(error == RT_ERROR_FEATURE_NOT_SUPPORT, ACL_ERROR_RT_FEATURE_NOT_SUPPORT);

    ERROR_RETURN_WITH_EXT_ERRCODE(error);

    return ACL_RT_SUCCESS;

}



#ifdef __cplusplus

}

#endif // __cplusplus