From dabd399a6aa97d71c500b6dea2ac08108746e600 Mon Sep 17 00:00:00 2001 From: yanghaoran Date: Thu, 3 Dec 2020 19:32:15 +0800 Subject: [PATCH] update runtime error code definition --- inc/external/runtime/rt_error_codes.h | 91 ++++++ src/ge/ge_runtime/runtime_model.cc | 40 +-- src/ge/ge_runtime/task/aicpu_task.cc | 18 +- src/ge/ge_runtime/task/cce_task.cc | 22 +- src/ge/ge_runtime/task/event_record_task.cc | 2 +- src/ge/ge_runtime/task/event_wait_task.cc | 4 +- src/ge/ge_runtime/task/hccl_task.cc | 12 +- src/ge/ge_runtime/task/label_goto_task.cc | 2 +- src/ge/ge_runtime/task/label_set_task.cc | 2 +- src/ge/ge_runtime/task/label_switch_task.cc | 8 +- src/ge/ge_runtime/task/memcpy_async_task.cc | 2 +- src/ge/ge_runtime/task/profiler_task.cc | 2 +- src/ge/ge_runtime/task/stream_active_task.cc | 2 +- src/ge/ge_runtime/task/stream_switch_task.cc | 2 +- src/ge/ge_runtime/task/task.h | 1 + src/ge/ge_runtime/task/tbe_task.cc | 10 +- third_party/fwkacllib/inc/register/op_tiling.h | 21 +- .../fwkacllib/inc/register/op_tiling_registry.h | 130 ++++++--- third_party/fwkacllib/inc/runtime/base.h | 305 +-------------------- 19 files changed, 246 insertions(+), 430 deletions(-) create mode 100644 inc/external/runtime/rt_error_codes.h diff --git a/inc/external/runtime/rt_error_codes.h b/inc/external/runtime/rt_error_codes.h new file mode 100644 index 00000000..0ae5303d --- /dev/null +++ b/inc/external/runtime/rt_error_codes.h @@ -0,0 +1,91 @@ +/** + * Copyright 2019-2020 Huawei Technologies Co., Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __INC_EXTERNEL_RT_ERROR_CODES_H__ +#define __INC_EXTERNEL_RT_ERROR_CODES_H__ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +static const int32_t ACL_RT_SUCCESS = 0; // success + +static const int32_t ACL_ERROR_RT_PARAM_INVALID = 107000; // param invalid +static const int32_t ACL_ERROR_RT_INVALID_DEVICEID = 107001; // invalid device id +static const int32_t ACL_ERROR_RT_CONTEXT_NULL = 107002; // current context null +static const int32_t ACL_ERROR_RT_STREAM_CONTEXT = 107003; // stream not in current context +static const int32_t ACL_ERROR_RT_MODEL_CONTEXT = 107004; // model not in current context +static const int32_t ACL_ERROR_RT_STREAM_MODEL = 107005; // stream not in model +static const int32_t ACL_ERROR_RT_EVENT_TIMESTAMP_INVALID = 107006; // event timestamp invalid +static const int32_t ACL_ERROR_RT_EVENT_TIMESTAMP_REVERSAL = 107007; // event timestamp reversal +static const int32_t ACL_ERROR_RT_ADDR_UNALIGNED = 107008; // memory address unaligned +static const int32_t ACL_ERROR_RT_FILE_OPEN = 107009; // open file failed +static const int32_t ACL_ERROR_RT_FILE_WRITE = 107010; // write file failed +static const int32_t ACL_ERROR_RT_STREAM_SUBSCRIBE = 107011; // error subscribe stream +static const int32_t ACL_ERROR_RT_THREAD_SUBSCRIBE = 107012; // error subscribe thread +static const int32_t ACL_ERROR_RT_GROUP_NOT_SET = 107013; // group not set +static const int32_t ACL_ERROR_RT_GROUP_NOT_CREATE = 107014; // group not create +static const int32_t ACL_ERROR_RT_STREAM_NO_CB_REG = 107015; // callback not register to stream +static const int32_t ACL_ERROR_RT_INVALID_MEMORY_TYPE = 107016; // invalid memory type + +static const int32_t ACL_ERROR_RT_FEATURE_NOT_SUPPROT = 207000; // feature not support +static const int32_t ACL_ERROR_RT_MEMORY_ALLOCATION = 207001; // memory allocation error +static const int32_t ACL_ERROR_RT_MEMORY_FREE = 207002; // memory free error + +static const int32_t ACL_ERROR_RT_INTERNEL_ERROR = 507000; // runtime internel error +static const int32_t ACL_ERROR_RT_TS_ERROR = 507001; // ts internel error +static const int32_t ACL_ERROR_RT_STREAM_TASK_FULL = 507002; // task full in stream +static const int32_t ACL_ERROR_RT_STREAM_TASK_EMPTY = 507003; // task empty in stream +static const int32_t ACL_ERROR_RT_STREAM_NOT_COMPLETE = 507004; // stream not complete +static const int32_t ACL_ERROR_RT_END_OF_SEQUENCE = 507005; // end of sequence +static const int32_t ACL_ERROR_RT_EVENT_NOT_COMPLETE = 507006; // event not complete +static const int32_t ACL_ERROR_RT_CONTEXT_RELEASE_ERROR = 507007; // context release error +static const int32_t ACL_ERROR_RT_SOC_VERSION = 507008; // soc version error +static const int32_t ACL_ERROR_RT_TASK_TYPE_NOT_SUPPORT = 507009; // task type not support +static const int32_t ACL_ERROR_RT_LOST_HEARTBEAT = 507010; // ts lost heartbeat +static const int32_t ACL_ERROR_RT_MODEL_EXECUTE = 507011; // model execute failed +static const int32_t ACL_ERROR_RT_REPORT_TIMEOUT = 507012; // report timeout +static const int32_t ACL_ERROR_RT_SYS_DMA = 507013; // sys dma error +static const int32_t ACL_ERROR_RT_AICORE_TIMEOUT = 507014; // aicore timeout +static const int32_t ACL_ERROR_RT_AICORE_EXCEPTION = 507015; // aicore exception +static const int32_t ACL_ERROR_RT_AICORE_TRAP_EXCEPTION = 507016; // aicore trap exception +static const int32_t ACL_ERROR_RT_AICPU_TIMEOUT = 507017; // aicpu timeout +static const int32_t ACL_ERROR_RT_AICPU_EXCEPTION = 507018; // aicpu exception +static const int32_t ACL_ERROR_RT_AICPU_DATADUMP_RSP_ERR = 507019; // aicpu datadump response error +static const int32_t ACL_ERROR_RT_AICPU_MODEL_RSP_ERR = 507020; // aicpu model operate response error +static const int32_t ACL_ERROR_RT_PROFILING_ERROR = 507021; // profiling error +static const int32_t ACL_ERROR_RT_IPC_ERROR = 507022; // ipc error +static const int32_t ACL_ERROR_RT_MODEL_ABORT_NORMAL = 507023; // model abort normal +static const int32_t ACL_ERROR_RT_KERNEL_UNREGISTERING = 507024; // kernel unregistering +static const int32_t ACL_ERROR_RT_RINGBUFFER_NOT_INIT = 507025; // ringbuffer not init +static const int32_t ACL_ERROR_RT_RINGBUFFER_NO_DATA = 507026; // ringbuffer no data +static const int32_t ACL_ERROR_RT_KERNEL_LOOKUP = 507027; // kernel lookup error +static const int32_t ACL_ERROR_RT_KERNEL_DUPLICATE = 507028; // kernel register duplicate +static const int32_t ACL_ERROR_RT_DEBUG_REGISTER_FAIL = 507029; // debug register failed +static const int32_t ACL_ERROR_RT_DEBUG_UNREGISTER_FAIL = 507030; // debug unregister failed +static const int32_t ACL_ERROR_RT_LABEL_CONTEXT = 507031; // label not in current context +static const int32_t ACL_ERROR_RT_PROGRAM_USE_OUT = 507032; // program register num use out +static const int32_t ACL_ERROR_RT_DEV_SETUP_ERROR = 507033; // device setup error + +static const int32_t ACL_ERROR_RT_DRV_INTERNEL_ERROR = 507899; // drv internel error + +#ifdef __cplusplus +} +#endif + +#endif // __INC_EXTERNEL_RT_ERROR_CODES_H__ diff --git a/src/ge/ge_runtime/runtime_model.cc b/src/ge/ge_runtime/runtime_model.cc index 35342988..2ba96a23 100644 --- a/src/ge/ge_runtime/runtime_model.cc +++ b/src/ge/ge_runtime/runtime_model.cc @@ -78,7 +78,7 @@ bool RuntimeModel::InitStream(std::shared_ptr &davinci_model) { : (RT_STREAM_PERSISTENT); rtError_t rt_ret = rtStreamCreateWithFlags(&stream, davinci_model->GetPriority(), flag); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api rtStreamCreate failed, ret: 0x%X", rt_ret); return false; } @@ -91,7 +91,7 @@ bool RuntimeModel::InitStream(std::shared_ptr &davinci_model) { flag = (wait_active_streams.find(i) != wait_active_streams.end()) ? (static_cast(RT_INVALID_FLAG)) : (static_cast(RT_HEAD_STREAM)); rt_ret = rtModelBindStream(rt_model_handle_, stream, flag); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api rtModelBindStream failed, ret: 0x%X", rt_ret); return false; } @@ -106,7 +106,7 @@ bool RuntimeModel::InitEvent(uint32_t event_num) { for (uint32_t i = 0; i < event_num; ++i) { rtEvent_t rt_event; rtError_t rt_ret = rtEventCreate(&rt_event); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api rtEventCreate failed, i; %u; ret: 0x%X", i, rt_ret); return false; } @@ -136,7 +136,7 @@ bool RuntimeModel::InitLabel(std::shared_ptr &davinci_model) { rtLabel_t rt_label = nullptr; rtError_t rt_ret = rtLabelCreateEx(&rt_label, stream_list_[label_set_task_info->stream_id()]); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api rtLabelCreate failed, ret: 0x%X", rt_ret); return false; } @@ -153,14 +153,14 @@ bool RuntimeModel::InitResource(std::shared_ptr &davinci_model) { return false; } rtError_t rt_ret = rtModelCreate(&rt_model_handle_, 0); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api rtModelCreate failed, ret: 0x%X", rt_ret); return false; } // Create rtStream for rt_model_handle_ rt_ret = rtStreamCreate(&rt_model_stream_, davinci_model->GetPriority()); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api rtStreamCreate failed, ret: 0x%X", rt_ret); return false; } @@ -214,7 +214,7 @@ bool RuntimeModel::LoadTask() { uint32_t task_id = 0; uint32_t stream_id = 0; rtError_t rt_ret = rtModelGetTaskId(rt_model_handle_, &task_id, &stream_id); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api failed, ret: 0x%X.", rt_ret); return false; } @@ -242,7 +242,7 @@ bool RuntimeModel::LoadComplete() { uint32_t task_id = 0; uint32_t stream_id = 0; auto rt_ret = rtModelGetTaskId(rt_model_handle_, &task_id, &stream_id); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rtModelGetTaskId failed, ret:0x%X", rt_ret); return RT_FAILED; } @@ -250,7 +250,7 @@ bool RuntimeModel::LoadComplete() { stream_id_list_.push_back(stream_id); rt_ret = rtModelLoadComplete(rt_model_handle_); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api rtModelLoadComplete failed, ret: 0x%X.", rt_ret); return false; } @@ -298,7 +298,7 @@ bool RuntimeModel::DistributeTask() { bool RuntimeModel::Run() { GELOGI("Davinci task run start"); rtError_t ret = rtModelExecute(rt_model_handle_, rt_model_stream_, 0); - if (ret != RT_ERROR_NONE) { + if (ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Model execute failed, ret = 0x%X", ret); return false; } @@ -306,8 +306,8 @@ bool RuntimeModel::Run() { GELOGI("Run rtModelExecute success, ret = 0x%X", ret); ret = rtStreamSynchronize(rt_model_stream_); - if (ret != RT_ERROR_NONE) { - if (ret == RT_ERROR_END_OF_SEQUENCE) { + if (ret != ACL_RT_SUCCESS) { + if (ret == ACL_ERROR_RT_END_OF_SEQUENCE) { GELOGI("Model stream RT_ERROR_END_OF_SEQUENCE signal received, ret = 0x%X", ret); return true; } @@ -321,7 +321,7 @@ bool RuntimeModel::Run() { void RuntimeModel::RtModelUnbindStream() noexcept { for (size_t i = 0; i < stream_list_.size(); i++) { - if (rtModelUnbindStream(rt_model_handle_, stream_list_[i]) != RT_ERROR_NONE) { + if (rtModelUnbindStream(rt_model_handle_, stream_list_[i]) != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Unbind stream from model failed! Index: %zu", i); return; } @@ -329,13 +329,13 @@ void RuntimeModel::RtModelUnbindStream() noexcept { } void RuntimeModel::RtStreamDestory() noexcept { - if (rtStreamDestroy(rt_model_stream_) != RT_ERROR_NONE) { + if (rtStreamDestroy(rt_model_stream_) != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Destroy stream for rt_model failed!"); return; } for (size_t i = 0; i < stream_list_.size(); i++) { - if (rtStreamDestroy(stream_list_[i]) != RT_ERROR_NONE) { + if (rtStreamDestroy(stream_list_[i]) != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Destroy stream failed! Index: %zu", i); return; } @@ -347,7 +347,7 @@ void RuntimeModel::RtLabelDestory() noexcept { if (label_list_[i] == nullptr) { continue; } - if (rtLabelDestroy(label_list_[i]) != RT_ERROR_NONE) { + if (rtLabelDestroy(label_list_[i]) != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Destroy label failed! Index: %zu.", i); return; } @@ -356,7 +356,7 @@ void RuntimeModel::RtLabelDestory() noexcept { void RuntimeModel::RtModelDestory() noexcept { rtError_t ret = rtModelDestroy(rt_model_handle_); - if (ret != RT_ERROR_NONE) { + if (ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api failed, ret: 0x%X", ret); return; } @@ -364,7 +364,7 @@ void RuntimeModel::RtModelDestory() noexcept { void RuntimeModel::RtEventDestory() noexcept { for (size_t i = 0; i < event_list_.size(); i++) { - if (rtEventDestroy(event_list_[i]) != RT_ERROR_NONE) { + if (rtEventDestroy(event_list_[i]) != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Destroy event failed! Index: %zu", i); return; } @@ -436,7 +436,7 @@ bool RuntimeModel::CopyHostData(const std::vector &data, const std:: void *data_out_addr = reinterpret_cast(outputs[0]); rtError_t rt_ret = rtMemcpy(data_out_addr, copy_size, host_data_addr, copy_size, RT_MEMCPY_HOST_TO_DEVICE); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api failed, ret: 0x%X", rt_ret); return false; } @@ -504,7 +504,7 @@ bool RuntimeModel::InitConstantInfo(std::shared_ptr &davinci_model rtError_t rt_ret = rtMemcpy(reinterpret_cast(constant->output_addrs[0]), constant->output_tensors[0].size, constant->weight_data.data(), constant->weight_data.size(), RT_MEMCPY_HOST_TO_DEVICE); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "rtGetFunctionByName failed, ret: 0x%X", rt_ret); return false; } diff --git a/src/ge/ge_runtime/task/aicpu_task.cc b/src/ge/ge_runtime/task/aicpu_task.cc index 5b3d8e82..3c7722f1 100644 --- a/src/ge/ge_runtime/task/aicpu_task.cc +++ b/src/ge/ge_runtime/task/aicpu_task.cc @@ -70,14 +70,14 @@ bool AicpuTask::Distribute() { aicpu_param_head.extInfoAddr = 0; } else { rtError_t flag = rtMalloc(&ext_info_, ext_size, RT_MEMORY_HBM); - if (flag != RT_ERROR_NONE) { + if (flag != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api(rtMalloc) failed, ret: 0x%X.", flag); return false; } flag = rtMemcpy(ext_info_, ext_size, const_cast(reinterpret_cast(ext_info.data())), ext_size, RT_MEMCPY_HOST_TO_DEVICE); - if (flag != RT_ERROR_NONE) { + if (flag != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api(rtMemCpy) failed, ret: 0x%X.", flag); return false; } @@ -89,7 +89,7 @@ bool AicpuTask::Distribute() { // Malloc device memory for args rtError_t rt_ret = rtMalloc(&args_, args_size, RT_MEMORY_HBM); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api(rtMalloc) failed, ret: 0x%X.", rt_ret); return false; } @@ -97,7 +97,7 @@ bool AicpuTask::Distribute() { // Memcpy AicpuParamHead rt_ret = rtMemcpy(args_, sizeof(aicpu::AicpuParamHead), reinterpret_cast(&aicpu_param_head), sizeof(aicpu::AicpuParamHead), RT_MEMCPY_HOST_TO_DEVICE); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api(rtMemcpy) failed, ret: 0x%X.", rt_ret); return false; } @@ -106,7 +106,7 @@ bool AicpuTask::Distribute() { if (io_addrs_num != 0) { rt_ret = rtMemcpy(reinterpret_cast(reinterpret_cast(args_) + io_addr_offset), io_addrs_size, reinterpret_cast(io_addrs.data()), io_addrs_size, RT_MEMCPY_HOST_TO_DEVICE); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api(rtMemcpy) failed, ret: 0x%X.", rt_ret); return false; } @@ -117,7 +117,7 @@ bool AicpuTask::Distribute() { rt_ret = rtMemcpy(reinterpret_cast(reinterpret_cast(args_) + node_def_len_offset), sizeof(uint32_t), reinterpret_cast(&size), sizeof(uint32_t), RT_MEMCPY_HOST_TO_DEVICE); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api(rtMemcpy) failed, ret: 0x%X.", rt_ret); return false; } @@ -126,7 +126,7 @@ bool AicpuTask::Distribute() { rt_ret = rtMemcpy(reinterpret_cast(reinterpret_cast(args_) + node_def_addr_offset), task_info_->node_def().size(), reinterpret_cast(task_info_->node_def().data()), task_info_->node_def().size(), RT_MEMCPY_HOST_TO_DEVICE); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api(rtMemcpy) failed, ret: 0x%X.", rt_ret); return false; } @@ -140,7 +140,7 @@ bool AicpuTask::Distribute() { rt_ret = rtCpuKernelLaunchWithFlag(reinterpret_cast(task_info_->so_name().data()), reinterpret_cast(task_info_->kernel_name().data()), 1, args_, args_size, nullptr, stream_, dump_flag); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api failed, ret: 0x%X", rt_ret); return false; } @@ -155,7 +155,7 @@ void AicpuTask::ReleaseRtMem(void **ptr) noexcept { } rtError_t rt_ret = rtFree(*ptr); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "ReleaseRtMem failed, ret: 0x%X", rt_ret); return; } diff --git a/src/ge/ge_runtime/task/cce_task.cc b/src/ge/ge_runtime/task/cce_task.cc index 04fd5610..cc5edaa6 100644 --- a/src/ge/ge_runtime/task/cce_task.cc +++ b/src/ge/ge_runtime/task/cce_task.cc @@ -45,8 +45,8 @@ CceTask::CceTask(const ModelContext &model_context, const std::shared_ptr(task_info_->stub_func().c_str()), &stub_func_); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "rtGetFunctionByName failed, ret: 0x%X", rt_ret); stub_func_ = nullptr; return false; @@ -87,7 +87,7 @@ bool CceTask::Distribute() { // Flowtable if (is_flowtable_) { rt_ret = rtMalloc(&flowtable_, task_info_->flow_table().size(), RT_MEMORY_HBM); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api failed, ret: 0x%X", rt_ret); return false; } @@ -95,7 +95,7 @@ bool CceTask::Distribute() { rt_ret = rtMemcpy(flowtable_, task_info_->flow_table().size(), task_info_->flow_table().data(), task_info_->flow_table().size(), RT_MEMCPY_HOST_TO_DEVICE); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api failed, ret: 0x%X", rt_ret); return false; } @@ -115,7 +115,7 @@ bool CceTask::Distribute() { // Args rt_ret = rtMalloc(&args_, task_info_->args_size(), RT_MEMORY_HBM); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api failed, ret: 0x%X", rt_ret); return false; } @@ -123,7 +123,7 @@ bool CceTask::Distribute() { rt_ret = rtMemcpy(args_, task_info_->args_size(), task_info_->args().data(), task_info_->args_size(), RT_MEMCPY_HOST_TO_DEVICE); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api failed, ret: 0x%X", rt_ret); return false; } @@ -131,14 +131,14 @@ bool CceTask::Distribute() { // L2 sm_desc if (!task_info_->sm_desc().empty()) { rt_ret = rtMemAllocManaged(&sm_desc_, task_info_->sm_desc().size(), RT_MEMORY_SPM); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api failed, ret: 0x%X", rt_ret); return false; } rt_ret = rtMemcpy(sm_desc_, task_info_->sm_desc().size(), task_info_->sm_desc().data(), task_info_->sm_desc().size(), RT_MEMCPY_HOST_TO_DEVICE); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api failed, ret: 0x%X", rt_ret); return false; } @@ -147,7 +147,7 @@ bool CceTask::Distribute() { // Kernel launch rt_ret = rtKernelLaunch(stub_func_, task_info_->block_dim(), args_, task_info_->args_size(), static_cast(sm_desc_), stream_); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api failed, ret: 0x%X", rt_ret); return false; } diff --git a/src/ge/ge_runtime/task/event_record_task.cc b/src/ge/ge_runtime/task/event_record_task.cc index 85ddc053..ac57b551 100644 --- a/src/ge/ge_runtime/task/event_record_task.cc +++ b/src/ge/ge_runtime/task/event_record_task.cc @@ -46,7 +46,7 @@ bool EventRecordTask::Distribute() { GELOGI("EventRecordTask Distribute start, stream: %p, event: %p, stream_id: %u, event_id: %u.", stream_, event_, task_info_->stream_id(), task_info_->event_id()); rtError_t rt_ret = rtEventRecord(event_, stream_); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api failed, ret: 0x%X", rt_ret); return false; } diff --git a/src/ge/ge_runtime/task/event_wait_task.cc b/src/ge/ge_runtime/task/event_wait_task.cc index 558c2a59..821ec8a1 100644 --- a/src/ge/ge_runtime/task/event_wait_task.cc +++ b/src/ge/ge_runtime/task/event_wait_task.cc @@ -46,13 +46,13 @@ bool EventWaitTask::Distribute() { task_info_->stream_id(), task_info_->event_id()); rtError_t rt_ret = rtStreamWaitEvent(stream_, event_); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api rtStreamWaitEvent failed, ret: 0x%X", rt_ret); return false; } rt_ret = rtEventReset(event_, stream_); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api rtEventReset failed, ret: 0x%X", rt_ret); return false; } diff --git a/src/ge/ge_runtime/task/hccl_task.cc b/src/ge/ge_runtime/task/hccl_task.cc index 4d76e492..e142c5f7 100644 --- a/src/ge/ge_runtime/task/hccl_task.cc +++ b/src/ge/ge_runtime/task/hccl_task.cc @@ -54,7 +54,7 @@ HcclTask::HcclTask(const ModelContext &model_context, const std::shared_ptrworkspace_size() > 0) { rtError_t rt_ret = rtMalloc(&workspace_mem_, task_info_->workspace_size(), RT_MEMORYINFO_HBM); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api failed, ret: 0x%X", rt_ret); return false; } @@ -229,13 +229,13 @@ bool HcclTask::CreateStream(rtModel_t model, rtStream_t *stream) const { } rtError_t rt_ret = rtStreamCreateWithFlags(stream, priority_, RT_STREAM_PERSISTENT | RT_STREAM_FORCE_COPY); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api failed, ret: 0x%X", rt_ret); return false; } // Create secondary stream, inactive by default, activated by hccl rt_ret = rtModelBindStream(model, *stream, RT_MODEL_WAIT_ACTIVE_STREAM); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api failed, ret: 0x%X", rt_ret); return false; } @@ -253,13 +253,13 @@ void HcclTask::SaveHcclSecondaryStream(int64_t master_stream_id, const std::shar HcclTask::StreamGuard::~StreamGuard() { rtError_t rt_ret = rtModelUnbindStream(model_, stream_); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Unbind stream from model failed!"); return; } rt_ret = rtStreamDestroy(stream_); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Destroy stream failed!"); return; } diff --git a/src/ge/ge_runtime/task/label_goto_task.cc b/src/ge/ge_runtime/task/label_goto_task.cc index d357accb..eb195df4 100644 --- a/src/ge/ge_runtime/task/label_goto_task.cc +++ b/src/ge/ge_runtime/task/label_goto_task.cc @@ -55,7 +55,7 @@ bool LabelGotoTask::Distribute() { return false; } rtError_t rt_ret = rtLabelGotoEx(label_, stream_); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api failed, ret: 0x%X", rt_ret); return false; } diff --git a/src/ge/ge_runtime/task/label_set_task.cc b/src/ge/ge_runtime/task/label_set_task.cc index 3ab5802c..923e16cd 100644 --- a/src/ge/ge_runtime/task/label_set_task.cc +++ b/src/ge/ge_runtime/task/label_set_task.cc @@ -55,7 +55,7 @@ bool LabelSetTask::Distribute() { return false; } rtError_t rt_ret = rtLabelSet(label_, stream_); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api failed, ret: 0x%X", rt_ret); return false; } diff --git a/src/ge/ge_runtime/task/label_switch_task.cc b/src/ge/ge_runtime/task/label_switch_task.cc index a3c2d41a..bb5c4199 100644 --- a/src/ge/ge_runtime/task/label_switch_task.cc +++ b/src/ge/ge_runtime/task/label_switch_task.cc @@ -45,7 +45,7 @@ LabelSwitchTask::LabelSwitchTask(const ModelContext &model_context, LabelSwitchTask::~LabelSwitchTask() { if (label_info_ != nullptr) { rtError_t rt_ret = rtFree(label_info_); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "rtFree fwkOpBuf failed! ret: 0x%X.", rt_ret); } label_info_ = nullptr; @@ -74,19 +74,19 @@ bool LabelSwitchTask::Distribute() { uint32_t label_info_size = sizeof(rtLabelDevInfo) * task_info_->label_size(); rtError_t rt_ret = rtMalloc(&label_info_, label_info_size, RT_MEMORY_HBM); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api failed, ret: 0x%X", rt_ret); return false; } rt_ret = rtLabelListCpy(label_list.data(), label_list.size(), label_info_, label_info_size); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api failed, ret: 0x%X", rt_ret); return false; } rt_ret = rtLabelSwitchByIndex(task_info_->cond(), label_list.size(), label_info_, stream_); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api failed, ret: 0x%X", rt_ret); return false; } diff --git a/src/ge/ge_runtime/task/memcpy_async_task.cc b/src/ge/ge_runtime/task/memcpy_async_task.cc index 8c09b379..d6d15cff 100644 --- a/src/ge/ge_runtime/task/memcpy_async_task.cc +++ b/src/ge/ge_runtime/task/memcpy_async_task.cc @@ -42,7 +42,7 @@ bool MemcpyAsyncTask::Distribute() { GELOGI("dst_max:%lu, count:%lu, kind:%u.", task_info_->dst_max(), task_info_->count(), task_info_->kind()); rtError_t rt_ret = rtMemcpyAsync(task_info_->dst(), task_info_->dst_max(), task_info_->src(), task_info_->count(), static_cast(task_info_->kind()), stream_); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api failed, ret: 0x%X", rt_ret); return false; } diff --git a/src/ge/ge_runtime/task/profiler_task.cc b/src/ge/ge_runtime/task/profiler_task.cc index 535c4f36..c5fc0405 100644 --- a/src/ge/ge_runtime/task/profiler_task.cc +++ b/src/ge/ge_runtime/task/profiler_task.cc @@ -39,7 +39,7 @@ bool ProfilerTask::Distribute() { GELOGI("ProfilerTask Distribute start."); GELOGI("logid = %lu, notify = %d, flat = %u.", task_info_->log_id(), task_info_->notify(), task_info_->flat()); rtError_t rt_ret = rtProfilerTrace(task_info_->log_id(), task_info_->notify(), task_info_->flat(), stream_); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api failed, ret: 0x%X", rt_ret); return false; } diff --git a/src/ge/ge_runtime/task/stream_active_task.cc b/src/ge/ge_runtime/task/stream_active_task.cc index d58b8942..618e96b0 100644 --- a/src/ge/ge_runtime/task/stream_active_task.cc +++ b/src/ge/ge_runtime/task/stream_active_task.cc @@ -45,7 +45,7 @@ bool StreamActiveTask::Distribute() { GELOGI("Distribute start"); GELOGI("Stream %u active %u.", task_info_->stream_id(), task_info_->active_stream_id()); rtError_t rt_ret = rtStreamActive(active_stream_, stream_); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api failed, ret: 0x%X", rt_ret); return false; } diff --git a/src/ge/ge_runtime/task/stream_switch_task.cc b/src/ge/ge_runtime/task/stream_switch_task.cc index 2adcb4bd..4aa3862e 100644 --- a/src/ge/ge_runtime/task/stream_switch_task.cc +++ b/src/ge/ge_runtime/task/stream_switch_task.cc @@ -67,7 +67,7 @@ bool StreamSwitchTask::Distribute() { GELOGI("StreamSwitchTask Distribute Start."); rtError_t rt_ret = rtStreamSwitchEx(input, cond, value, true_stream, stream_, data_type); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api failed, ret: 0x%X", rt_ret); return false; } diff --git a/src/ge/ge_runtime/task/task.h b/src/ge/ge_runtime/task/task.h index 6c4df248..c255fd22 100644 --- a/src/ge/ge_runtime/task/task.h +++ b/src/ge/ge_runtime/task/task.h @@ -24,6 +24,7 @@ #include "runtime/rt_model.h" #include "ge_runtime/model_context.h" #include "ge_runtime/task_info.h" +#include "external/runtime/rt_error_codes.h" namespace ge { namespace model_runner { diff --git a/src/ge/ge_runtime/task/tbe_task.cc b/src/ge/ge_runtime/task/tbe_task.cc index e7025ae8..d541fe40 100644 --- a/src/ge/ge_runtime/task/tbe_task.cc +++ b/src/ge/ge_runtime/task/tbe_task.cc @@ -44,7 +44,7 @@ TbeTask::TbeTask(const ModelContext &model_context, const std::shared_ptr(task_info_->stub_func().c_str()), &stub_func_); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "rtGetFunctionByName failed, ret: %d", static_cast(rt_ret)); stub_func_ = nullptr; return false; @@ -82,7 +82,7 @@ bool TbeTask::Distribute() { auto args_size = static_cast(tensor_device_addrs.size() * sizeof(void *)); rt_ret = rtMalloc(&args_, args_size, RT_MEMORY_HBM); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "rtMalloc failed, ret: %d", static_cast(rt_ret)); return false; } @@ -90,7 +90,7 @@ bool TbeTask::Distribute() { rt_ret = rtMemcpy(args_, args_size, reinterpret_cast(tensor_device_addrs.data()), args_size, RT_MEMCPY_HOST_TO_DEVICE); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "rtMemcpy fail, ret 0x%X.", rt_ret); return false; } @@ -98,7 +98,7 @@ bool TbeTask::Distribute() { GELOGI("DistributeTbeTask start."); auto dump_flag = task_info_->dump_flag() ? RT_KERNEL_DUMPFLAG : RT_KERNEL_DEFAULT; rt_ret = rtKernelLaunchWithFlag(stub_func_, task_info_->block_dim(), args_, args_size, nullptr, stream_, dump_flag); - if (rt_ret != RT_ERROR_NONE) { + if (rt_ret != ACL_RT_SUCCESS) { GELOGE(RT_FAILED, "Call rt api rtKernelLaunch failed, ret: 0x%X", rt_ret); return false; } diff --git a/third_party/fwkacllib/inc/register/op_tiling.h b/third_party/fwkacllib/inc/register/op_tiling.h index f720afec..e94ad556 100644 --- a/third_party/fwkacllib/inc/register/op_tiling.h +++ b/third_party/fwkacllib/inc/register/op_tiling.h @@ -20,29 +20,12 @@ #include "graph/debug/ge_attr_define.h" #include "graph/node.h" #include "register/op_tiling_registry.h" -#include namespace optiling { -#define REGISTER_OP_TILING_FUNC(optype, opfunc) REGISTER_OP_TILING_FUNC_UNIQ_HELPER(optype, opfunc, __COUNTER__) -#define REGISTER_OP_TILING_FUNC_UNIQ_HELPER(optype, opfunc, counter) \ - REGISTER_OP_TILING_FUNC_UNIQ(optype, opfunc, counter) -#define REGISTER_OP_TILING_FUNC_UNIQ(optype, opfunc, counter) \ - static OpTilingInterf g_##optype##TilingInterf##counter(#optype, opfunc) - -using OpTilingFuncOld = - std::function; - -class FMK_FUNC_HOST_VISIBILITY OpTilingInterf { - public: - OpTilingInterf(std::string op_type, OpTilingFuncOld func); - ~OpTilingInterf() = default; - static std::string OpTilingUuid; -}; - extern "C" ge::graphStatus OpParaCalculate(const ge::Node &node, OpRunInfo &run_info); extern "C" ge::graphStatus OpAtomicCalculate(const ge::Node &node, OpRunInfo &run_info); -} // namespace optiling +} -#endif // INC_REGISTER_OP_TILING_H_ +#endif // INC_REGISTER_OP_TILING_H_ diff --git a/third_party/fwkacllib/inc/register/op_tiling_registry.h b/third_party/fwkacllib/inc/register/op_tiling_registry.h index c6efabda..dbc00fab 100644 --- a/third_party/fwkacllib/inc/register/op_tiling_registry.h +++ b/third_party/fwkacllib/inc/register/op_tiling_registry.h @@ -19,93 +19,135 @@ #include #include +#include #include #include #include #include "external/register/register_types.h" #include "external/graph/tensor.h" -#define REGISTER_OP_TILING(optype, opfunc) REGISTER_OP_TILING_UNIQ_HELPER(optype, opfunc, __COUNTER__) +#define REGISTER_OP_TILING_FUNC(optype, opfunc) \ + REGISTER_OP_TILING_FUNC_UNIQ_HELPER(optype, opfunc, __COUNTER__) -#define REGISTER_OP_TILING_FUNC_NEW(optype, opfunc) REGISTER_OP_TILING_UNIQ_HELPER(optype, opfunc, __COUNTER__) +#define REGISTER_OP_TILING_FUNC_UNIQ_HELPER(optype, opfunc, counter) \ + REGISTER_OP_TILING_FUNC_UNIQ(optype, opfunc, counter) -#define REGISTER_OP_TILING_UNIQ_HELPER(optype, opfunc, counter) REGISTER_OP_TILING_UNIQ(optype, opfunc, counter) +#define REGISTER_OP_TILING_FUNC_UNIQ(optype, opfunc, counter) \ + static OpTilingInterf g_##optype##TilingInterf##counter(#optype, opfunc) -#define REGISTER_OP_TILING_UNIQ(optype, opfunc, counter) \ - static OpTilingRegistryInterf g_##optype##TilingRegistryInterf##counter(#optype, opfunc) +#define REGISTER_OP_TILING_FUNC_NEW(optype, opfunc) \ + REGISTER_OP_TILING_UNIQ_HELPER(optype, opfunc, __COUNTER__) + +#define REGISTER_OP_TILING(optype, opfunc) \ + REGISTER_OP_TILING_UNIQ_HELPER(optype, opfunc, __COUNTER__) + +#define REGISTER_OP_TILING_UNIQ_HELPER(optype, opfunc, counter) \ + REGISTER_OP_TILING_UNIQ(optype, opfunc, counter) + +#define REGISTER_OP_TILING_UNIQ(optype, opfunc, counter) \ + static OpTilingRegistryInterf g_##optype##TilingRegistryInterf##counter(#optype, opfunc) namespace optiling { enum TensorArgType { - TA_NONE, - TA_SINGLE, - TA_LIST, + TA_NONE, + TA_SINGLE, + TA_LIST, }; using ByteBuffer = std::stringstream; struct TeOpTensor { - std::vector shape; - std::vector ori_shape; - std::string format; - std::string ori_format; - std::string dtype; - std::map attrs; + std::vector shape; + std::vector ori_shape; + std::string format; + std::string ori_format; + std::string dtype; + std::map attrs; }; + struct TeOpTensorArg { - TensorArgType arg_type; - std::vector tensor; + TensorArgType arg_type; + std::vector tensor; }; struct OpRunInfo { - uint32_t block_dim; - std::vector workspaces; - ByteBuffer tiling_data; - bool clear_atomic; + uint32_t block_dim; + std::vector workspaces; + ByteBuffer tiling_data; + bool clear_atomic; }; + using TeOpAttrArgs = std::vector; -using TeConstTensorData = std::tuple; +using TeConstTensorData = std::tuple; struct TeOpParas { - std::vector inputs; - std::vector outputs; - std::map const_inputs; - TeOpAttrArgs attrs; - std::string op_type; + std::vector inputs; + std::vector outputs; + std::map const_inputs; + TeOpAttrArgs attrs; + std::string op_type; +}; + + +using OpTilingFunc = std::function; + +using OpTilingFuncPtr = bool(*)(const std::string&, const TeOpParas&, const nlohmann::json& , OpRunInfo&); + +class FMK_FUNC_HOST_VISIBILITY OpTilingInterf +{ +public: + OpTilingInterf(std::string op_type, OpTilingFunc func); + ~OpTilingInterf() = default; + static std::map &RegisteredOpInterf(); + static std::string OpTilingUuid; }; struct OpCompileInfo { - std::string str; - std::string key; + std::string str; + std::string key; }; -using OpTilingFunc = std::function; +using OpTilingFuncNew = std::function; -using OpTilingFuncPtr = bool (*)(const TeOpParas &, const OpCompileInfo &, OpRunInfo &); +using OpTilingFuncPtrNew = bool(*)(const TeOpParas&, const OpCompileInfo& , OpRunInfo&); class FMK_FUNC_HOST_VISIBILITY OpTilingRegistryInterf { - public: - OpTilingRegistryInterf(std::string op_type, OpTilingFunc func); - ~OpTilingRegistryInterf() = default; - static std::map &RegisteredOpInterf(); +public: + OpTilingRegistryInterf(std::string op_type, OpTilingFuncNew func); + ~OpTilingRegistryInterf() = default; + static std::map &RegisteredOpInterf(); }; template -ByteBuffer &ByteBufferPut(ByteBuffer &buf, const T &value) { - buf.write(reinterpret_cast(&value), sizeof(value)); - buf.flush(); - return buf; +ByteBuffer& ByteBufferPut(ByteBuffer &buf, const T &value) +{ + buf.write(reinterpret_cast(&value), sizeof(value)); + buf.flush(); + return buf; } template -ByteBuffer &ByteBufferGet(ByteBuffer &buf, T &value) { - buf.read(reinterpret_cast(&value), sizeof(value)); - return buf; +ByteBuffer& ByteBufferGet(ByteBuffer &buf, T &value) +{ + buf.read(reinterpret_cast(&value), sizeof(value)); + return buf; } -size_t ByteBufferGetAll(ByteBuffer &buf, char *dest, size_t dest_len); -} // namespace optiling +inline size_t ByteBufferGetAll(ByteBuffer &buf, char *dest, size_t dest_len) +{ + size_t nread = 0; + size_t rn = 0; + do { + rn = buf.readsome(dest + nread, dest_len - nread); + nread += rn; + } while (rn > 0 && dest_len > nread); + + return nread; +} +} -#endif // INC_REGISTER_OP_TILING_REGISTRY_H_ +#endif // INC_REGISTER_OP_TILING_REGISTRY_H_ diff --git a/third_party/fwkacllib/inc/runtime/base.h b/third_party/fwkacllib/inc/runtime/base.h index 4e735438..45bb6782 100644 --- a/third_party/fwkacllib/inc/runtime/base.h +++ b/third_party/fwkacllib/inc/runtime/base.h @@ -32,309 +32,8 @@ extern "C" { #endif #endif -/** - * @ingroup dvrt_base - * @brief runtime error numbers. - */ -typedef enum tagRtError { - RT_ERROR_NONE = 0x0, // success - - RT_ERROR_DEVICE_BASE = 0x07010000, - RT_ERROR_DEVICE_NULL, - RT_ERROR_DEVICE_NEW, - RT_ERROR_DEVICE_ID, - RT_ERROR_DEVICE_CHIPTYPE, - RT_ERROR_DEVICE_DEPLOY, - RT_ERROR_DEVICE_RETAIN, - RT_ERROR_DEVICE_PLATFORM, - RT_ERROR_DEVICE_LOADER, - RT_ERROR_DEVICE_LIMIT, - RT_ERROR_DEVICE_PROC_HANG_OUT, - RT_ERROR_DEVICE_POWER_UP_FAIL, - RT_ERROR_DEVICE_POWER_DOWN_FAIL, - RT_ERROR_DEVICE_INVALID, - - RT_ERROR_DRV_BASE = 0x07020000, - RT_ERROR_DRV_NULL, - RT_ERROR_DRV_NEW, - RT_ERROR_DRV_MEMORY, - RT_ERROR_DRV_INPUT, - RT_ERROR_DRV_PTRNULL, - RT_ERROR_DRV_OPEN_AICPU, - RT_ERROR_DRV_CLOSE_AICPU, - RT_ERROR_DRV_SYM_AICPU, - RT_ERROR_DRV_OPEN_TSD, - RT_ERROR_DRV_CLOSE_TSD, - RT_ERROR_DRV_SYM_TSD, - RT_ERROR_DRV_SOURCE, - RT_ERROR_DRV_REPORT, - RT_ERROR_DRV_COMMAND, - RT_ERROR_DRV_OCCUPY, - RT_ERROR_DRV_ERR, - - RT_ERROR_STREAM_BASE = 0x07030000, - RT_ERROR_STREAM_NULL, - RT_ERROR_STREAM_NEW, - RT_ERROR_STREAM_CONTEXT, - RT_ERROR_STREAM_INVALID, - RT_ERROR_STREAM_MODEL, - RT_ERROR_STREAM_FUSION, - RT_ERROR_STREAM_FULL, - RT_ERROR_STREAM_EMPTY, - RT_ERROR_STREAM_NOT_COMPLETE, - RT_ERROR_STREAM_SYNC, - RT_ERROR_STREAM_NO_CB_REG, - RT_ERROR_STREAM_DUPLICATE, - RT_ERROR_STREAM_NOT_EXIST, - RT_ERROR_SQ_NO_EXIST_SQ_TO_REUSE, - RT_ERROR_SQID_FULL, - - RT_ERROR_MODEL_BASE = 0x07040000, - RT_ERROR_MODEL_NULL, - RT_ERROR_MODEL_NEW, - RT_ERROR_MODEL_CONTEXT, - RT_ERROR_MODEL_ENDGRAPH, - RT_ERROR_MODEL_STREAM, - RT_ERROR_MODEL_EXCUTOR, - RT_ERROR_MODEL_SETUP, - RT_ERROR_MODEL_ID, - RT_ERROR_MODEL_EXE_FAILED, - RT_ERROR_END_OF_SEQUENCE, // end of sequence - RT_ERROR_MODEL_EXIT, - RT_ERROR_MODEL_EXIT_STREAM_UNBIND, - RT_ERROR_MODEL_EXIT_ID, - RT_ERROR_MODEL_ABORT_NORMAL, - - RT_ERROR_EVENT_BASE = 0x07050000, - RT_ERROR_EVENT_NULL, - RT_ERROR_EVENT_NEW, - RT_ERROR_EVENT_RECORDER_NULL, - RT_ERROR_EVENT_TIMESTAMP_INVALID, - RT_ERROR_EVENT_TIMESTAMP_REVERSAL, - RT_ERROR_EVENT_NOT_COMPLETE, - - RT_ERROR_NOTIFY_BASE = 0x07060000, - RT_ERROR_NOTIFY_NULL, - RT_ERROR_NOTIFY_NEW, - RT_ERROR_NOTIFY_TYPE, - RT_ERROR_NOTIFY_NOT_COMPLETE, - - RT_ERROR_CONTEXT_BASE = 0x07070000, - RT_ERROR_CONTEXT_NULL, - RT_ERROR_CONTEXT_NEW, - RT_ERROR_CONTEXT_DEL, - RT_ERROR_CONTEXT_DEFAULT_STREAM_NULL, - RT_ERROR_CONTEXT_ONLINE_STREAM_NULL, - - RT_ERROR_KERNEL_BASE = 0x07080000, - RT_ERROR_KERNEL_NULL, - RT_ERROR_KERNEL_NEW, - RT_ERROR_KERNEL_LOOKUP, - RT_ERROR_KERNEL_NAME, - RT_ERROR_KERNEL_TYPE, - RT_ERROR_KERNEL_OFFSET, - RT_ERROR_KERNEL_DUPLICATE, - RT_ERROR_KERNEL_UNREGISTERING, - - RT_ERROR_PROGRAM_BASE = 0x07090000, - RT_ERROR_PROGRAM_NULL, - RT_ERROR_PROGRAM_NEW, - RT_ERROR_PROGRAM_DATA, - RT_ERROR_PROGRAM_SIZE, - RT_ERROR_PROGRAM_MEM_TYPE, - RT_ERROR_PROGRAM_MACHINE_TYPE, - RT_ERROR_PROGRAM_USEOUT, - - RT_ERROR_MODULE_BASE = 0x070a0000, - RT_ERROR_MODULE_NULL, - RT_ERROR_MODULE_NEW, - - RT_ERROR_INSTANCE_BASE = 0x070b0000, - RT_ERROR_INSTANCE_NULL, - RT_ERROR_INSTANCE_NEW, - RT_ERROR_INSTANCE_VERSION, - - RT_ERROR_API_BASE = 0x070c0000, - RT_ERROR_API_NULL, - RT_ERROR_API_NEW, - - RT_ERROR_DATADUMP_BASE = 0x070d0000, - RT_ERROR_DATADUMP_NULL, - RT_ERROR_DATADUMP_NEW, - RT_ERROR_DATADUMP_TIME, - RT_ERROR_DATADUMP_FILE, - RT_ERROR_DATADUMP_ADDRESS, - RT_ERROR_DATADUMP_LOAD_FAILED, - RT_ERROR_DUMP_ADDR_SET_FAILED, - - RT_ERROR_PROF_BASE = 0x070e0000, - RT_ERROR_PROF_NULL, - RT_ERROR_PROF_NEW, - RT_ERROR_PROF_START, - RT_ERROR_PROF_DEVICE_MEM, - RT_ERROR_PROF_HOST_MEM, - RT_ERROR_PROF_SET_DIR, - RT_ERROR_PROF_OPER, - RT_ERROR_PROF_FULL, - RT_ERROR_PROF_NAME, - - RT_ERROR_PCTRACE_BASE = 0x070f0000, - RT_ERROR_PCTRACE_NULL, - RT_ERROR_PCTRACE_NEW, - RT_ERROR_PCTRACE_TIME, - RT_ERROR_PCTRACE_FILE, - - RT_ERROR_TASK_BASE = 0x07100000, - RT_ERROR_TASK_NULL, - RT_ERROR_TASK_NEW, - RT_ERROR_TASK_TYPE, - RT_ERROR_TASK_ALLOCATOR, - - RT_ERROR_COMMON_BASE = 0x07110000, - RT_ERROR_INVALID_VALUE, // RT_ERROR_INPUT_INVALID - RT_ERROR_MEMORY_ADDRESS_UNALIGNED, - RT_ERROR_SEC_HANDLE, - RT_ERROR_OS_HANDLE, - RT_ERROR_MUTEX_LOCK, - RT_ERROR_MUTEX_UNLOCK, - RT_ERROR_CALLOC, - RT_ERROR_POOL_RESOURCE, - RT_ERROR_TRANS_ARGS, - RT_ERROR_METADATA, - RT_ERROR_LOST_HEARTBEAT, - RT_ERROR_REPORT_TIMEOUT, - RT_ERROR_FEATURE_NOT_SUPPROT, - RT_ERROR_MEMORY_ALLOCATION, - RT_ERROR_MEMORY_FREE, - RT_ERROR_INVALID_MEMORY_TYPE, - - RT_ERROR_DEBUG_BASE = 0x07120000, - RT_ERROR_DEBUG_NULL, - RT_ERROR_DEBUG_NEW, - RT_ERROR_DEBUG_SIGNAL, - RT_ERROR_DEBUG_OPEN, - RT_ERROR_DEBUG_WRITE, - RT_ERROR_DEBUG_REGISTER_FAILED, - RT_ERROR_DEBUG_UNREGISTER_FAILED, - - RT_ERROR_ENGINE_BASE = 0x07130000, - RT_ERROR_ENGINE_NULL, - RT_ERROR_ENGINE_NEW, - RT_ERROR_ENGINE_THREAD, - - RT_ERROR_LABEL_BASE = 0x07140000, - RT_ERROR_LABEL_NULL, - RT_ERROR_LABEL_NEW, - RT_ERROR_LABEL_CONTEXT, - RT_ERROR_LABEL_STREAM, - RT_ERROR_LABEL_MODEL, - RT_ERROR_LABEL_ALLOCATOR, - RT_ERROR_LABEL_FREE, - RT_ERROR_LABEL_SET, - RT_ERROR_LABEL_ID, - - RT_ERROR_TSFW_BASE = 0x07150000, - RT_ERROR_TSFW_UNKNOWN, - RT_ERROR_TSFW_NULL_PTR, - RT_ERROR_TSFW_ILLEGAL_AI_CORE_ID, - RT_ERROR_TSFW_ILLEGAL_PARAM, - RT_ERROR_TSFW_TASK_CMD_QUEUE_FULL, - RT_ERROR_TSFW_TASK_CMD_QUEUE_EMPTY, - RT_ERROR_TSFW_TASK_REPORT_QUEUE_FULL, - RT_ERROR_TSFW_TASK_REPORT_QUEUE_EMPTY, - RT_ERROR_TSFW_TASK_NODE_BUFF_ALL_OCCUPYED, - RT_ERROR_TSFW_TASK_NODE_BUFF_ALL_FREED, - RT_ERROR_TSFW_L2_MEM_INSUFFICIENT_SPACE, - RT_ERROR_TSFW_L2_MALLOC_FAILED, - RT_ERROR_TSFW_DMA_CHANNEL_ALL_OCCUPYED, - RT_ERROR_TSFW_MEMCPY_OP_FAILED, - RT_ERROR_TSFW_BS_SLOT_ALL_OCCUPYED, - RT_ERROR_TSFW_TBS_SLOT_REPEAT_FREE, - RT_ERROR_TSFW_PRIORITY_TASK_LIST_FULL, - RT_ERROR_TSFW_PRIORITY_TASK_LIST_EMPTY, - RT_ERROR_TSFW_NO_STREAM_LIST_NEED_TO_BE_PROCESSED, - RT_ERROR_TSFW_REPEAT_MARK_STREAM_NEED_SERVICE, - RT_ERROR_TSFW_SYS_DMA_CHANNEL_ALL_OCCUPAPYED, - RT_ERROR_TSFW_NO_HBML2TASKNODE_FOUND, - RT_ERROR_TSFW_SQNODE_NODE_SLOT_ALL_OCCUPAPYED, - RT_ERROR_TSFW_CQNODE_NODE_SLOT_ALL_OCCUPAPYED, - RT_ERROR_TSFW_SQNODE_NOT_ENOUGH, - RT_ERROR_TSFW_SQNODE_SLOT_REPEAT_FREE, - RT_ERROR_TSFW_CQNODE_SLOT_REPEAT_FREE, - RT_ERROR_TSFW_CQ_REPORT_FAILED, - RT_ERROR_TSFW_SYS_DMA_RESET_SUCCESS, - RT_ERROR_TSFW_SYS_DMA_RESET_FAILED, - RT_ERROR_TSFW_SYS_DMA_TRNSFER_FAILED, - RT_ERROR_TSFW_SYS_DMA_MEMADDRALIGN_FAILED, - RT_ERROR_TSFW_SYS_DMA_ERROR_QUEUE_FULL, - RT_ERROR_TSFW_SYS_DMA_ERROR_QUEUE_EMPTY, - RT_ERROR_TSFW_TIMER_EVENT_FULL, - RT_ERROR_TSFW_TASK_L2_DESC_ENTRY_NOT_ENOUGH, - RT_ERROR_TSFW_AICORE_TIMEOUT, - RT_ERROR_TSFW_AICORE_EXCEPTION, - RT_ERROR_TSFW_AICORE_TRAP_EXCEPTION, - RT_ERROR_TSFW_AICPU_TIMEOUT, - RT_ERROR_TSFW_SDMA_L2_TO_DDR_MALLOC_FAIL, - RT_ERROR_TSFW_AICPU_EXCEPTION, - RT_ERROR_TSFW_AICPU_DATADUMP_RSP_ERR, - RT_ERROR_TSFW_AICPU_MODEL_RSP_ERR, - RT_ERROR_TSFW_REPEAT_ACTIVE_MODEL_STREAM, - RT_ERROR_TSFW_REPEAT_NOTIFY_WAIT, - RT_ERROR_TSFW_DEBUG_INVALID_SQCQ, - RT_ERROR_TSFW_DEBUG_WRONG_COMMAND_TYPE, - RT_ERROR_TSFW_DEBUG_CMD_PROCESS, - RT_ERROR_TSFW_DEBUG_INVALID_DEVICE_STATUS, - RT_ERROR_TSFW_DEBUG_NOT_IN_DEBUG_STATUS, - RT_ERROR_TSFW_DEBUG_INVALID_TASK_STATUS, - RT_ERROR_TSFW_DEBUG_TASK_EMPTY, - RT_ERROR_TSFW_DEBUG_TASK_FULL, - RT_ERROR_TSFW_DEBUG_TASK_NOT_EXIST, - RT_ERROR_TSFW_DEBUG_AI_CORE_FULL, - RT_ERROR_TSFW_DEBUG_AI_CORE_NOT_EXIST, - RT_ERROR_TSFW_DEBUG_AI_CORE_EXCEPTION, - RT_ERROR_TSFW_DEBUG_AI_CORE_TIMEOUT, - RT_ERROR_TSFW_DEBUG_BREAKPOINT_FULL, - RT_ERROR_TSFW_DEBUG_READ_ERROR, - RT_ERROR_TSFW_DEBUG_WRITE_FAIL, - RT_ERROR_TSFW_QUEUE_FULL, - RT_ERROR_TSFW_QUEUE_EMPTY, - RT_ERROR_TSFW_QUEUE_ALLOC_MEM_FAIL, - RT_ERROR_TSFW_QUEUE_DATA_SIZE_UNMATCH, - RT_ERROR_TSFW_PCIE_DMA_INVLD_CPY_TYPE, - RT_ERROR_TSFW_INVLD_CPY_DIR, - RT_ERROR_TSFW_PCIE_DMA_INVLD_CQ_DES, - RT_ERROR_TSFW_PCIE_DMA_CPY_ERR, - RT_ERROR_TSFW_PCIE_DMA_LNK_CHN_BUSY, - RT_ERROR_TSFW_PROFILE_BUFF_FULL, - RT_ERROR_TSFW_PROFILE_MODE_CONFLICT, - RT_ERROR_TSFW_PROFILE_OTHER_PID_ON, - RT_ERROR_TSFW_SCHD_AIC_TASK_PRELOAD_FAILED, - RT_ERROR_TSFW_TSCPU_CLOSE_FAILED, - RT_ERROR_TSFW_EXPECT_FAIL, - RT_ERROR_TSFW_REPEAT_MODEL_STREAM, - RT_ERROR_TSFW_STREAM_MODEL_UNBIND, - RT_ERROR_TSFW_MODEL_EXE_FAILED, - RT_ERROR_TSFW_IPC_SEND_FAILED, - RT_ERROR_TSFW_IPC_PROC_REG_FAILED, - RT_ERROR_TSFW_STREAM_FULL, - RT_ERROR_TSFW_END_OF_SEQUENCE, - RT_ERROR_TSFW_SWITCH_STREAM_LABEL, - RT_ERROR_TSFW_TRANS_SQE_FAIL, - RT_ERROR_TSFW_RESERVED, - - RT_ERROR_SUBSCRIBE_BASE = 0x07160000, - RT_ERROR_SUBSCRIBE_NULL, - RT_ERROR_SUBSCRIBE_NEW, - RT_ERROR_SUBSCRIBE_STREAM, - RT_ERROR_SUBSCRIBE_THREAD, - RT_ERROR_SUBSCRIBE_GROUP, - - RT_ERROR_GROUP_BASE = 0x07170000, - RT_ERROR_GROUP_NOT_SET, - RT_ERROR_GROUP_NOT_CREATE, - - RT_ERROR_RESERVED = 0x07ff0000, - }rtError_t; +typedef int32_t rtError_t; +static const int32_t RT_ERROR_NONE = 0; // success /** * @ingroup dvrt_base