m53297601
/
graphengine
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

update runtime error code definition

Browse Source
pull/503/head
yanghaoran 4 years ago
parent dd5ac69a1f
commit dabd399a6a
19 changed files with 246 additions and 430 deletions
Show Stats Download Patch File Download Diff File

91
inc/external/runtime/rt_error_codes.h vendored
Unescape View File

@ -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 <stddef.h>
#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__

40
src/ge/ge_runtime/runtime_model.cc
Unescape View File

@ -78,7 +78,7 @@ bool RuntimeModel::InitStream(std::shared_ptr<DavinciModel> &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<DavinciModel> &davinci_model) {
flag = (wait_active_streams.find(i) != wait_active_streams.end()) ? (static_cast<uint32_t>(RT_INVALID_FLAG))
: (static_cast<uint32_t>(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<DavinciModel> &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<DavinciModel> &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<DataBuffer> &data, const std::
void *data_out_addr = reinterpret_cast<void *>(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<DavinciModel> &davinci_model
rtError_t rt_ret = rtMemcpy(reinterpret_cast<void *>(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;
}

18
src/ge/ge_runtime/task/aicpu_task.cc
Unescape View File

@ -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<void *>(reinterpret_cast<const void *>(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<void *>(&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<void *>(reinterpret_cast<uint8_t *>(args_) + io_addr_offset), io_addrs_size,
reinterpret_cast<void *>(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<void *>(reinterpret_cast<uint8_t *>(args_) + node_def_len_offset), sizeof(uint32_t),
reinterpret_cast<const void *>(&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<void *>(reinterpret_cast<uint8_t *>(args_) + node_def_addr_offset),
task_info_->node_def().size(), reinterpret_cast<const void *>(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<const void *>(task_info_->so_name().data()),
reinterpret_cast<const void *>(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;
}

22
src/ge/ge_runtime/task/cce_task.cc
Unescape View File

@ -45,8 +45,8 @@ CceTask::CceTask(const ModelContext &model_context, const std::shared_ptr<CceTas
CceTask::~CceTask() {
FreeRtMem(&args_);
FreeRtMem(&flowtable_);
rtError_t ret = (sm_desc_ != nullptr) ? rtMemFreeManaged(sm_desc_) : RT_ERROR_NONE;
if (ret != RT_ERROR_NONE) {
rtError_t ret = (sm_desc_ != nullptr) ? rtMemFreeManaged(sm_desc_) : ACL_RT_SUCCESS;
if (ret != ACL_RT_SUCCESS) {
GELOGE(RT_FAILED, "Call rt api failed, ret: 0x%X", ret);
}
sm_desc_ = nullptr;
@ -57,7 +57,7 @@ void CceTask::FreeRtMem(void **ptr) noexcept {
return;
}
rtError_t ret = rtFree(*ptr);
if (ret != RT_ERROR_NONE) {
if (ret != ACL_RT_SUCCESS) {
GELOGE(RT_FAILED, "Call rt api failed, ret: 0x%X", ret);
}
@ -77,7 +77,7 @@ bool CceTask::Distribute() {
}
rtError_t rt_ret = rtGetFunctionByName(const_cast<char *>(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<rtSmDesc_t *>(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;
}

2
src/ge/ge_runtime/task/event_record_task.cc
Unescape View File

@ -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;
}

4
src/ge/ge_runtime/task/event_wait_task.cc
Unescape View File

@ -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;
}

12
src/ge/ge_runtime/task/hccl_task.cc
Unescape View File

@ -54,7 +54,7 @@ HcclTask::HcclTask(const ModelContext &model_context, const std::shared_ptr<Hccl
HcclTask::~HcclTask() {
if (workspace_mem_ != nullptr) {
rtError_t rt_ret = rtFree(workspace_mem_);
if (rt_ret != RT_ERROR_NONE) {
if (rt_ret != ACL_RT_SUCCESS) {
GELOGE(RT_FAILED, "rtFree workspace_mem_ failed! ret: 0x%X.", rt_ret);
}
workspace_mem_ = nullptr;
@ -79,7 +79,7 @@ bool HcclTask::Distribute() {
if (task_info_->workspace_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;
}

2
src/ge/ge_runtime/task/label_goto_task.cc
Unescape View File

@ -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;
}

2
src/ge/ge_runtime/task/label_set_task.cc
Unescape View File

@ -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;
}

8
src/ge/ge_runtime/task/label_switch_task.cc
Unescape View File

@ -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;
}

2
src/ge/ge_runtime/task/memcpy_async_task.cc
Unescape View File

@ -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<rtMemcpyKind_t>(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;
}

2
src/ge/ge_runtime/task/profiler_task.cc
Unescape View File

@ -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;
}

2
src/ge/ge_runtime/task/stream_active_task.cc
Unescape View File

@ -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;
}

2
src/ge/ge_runtime/task/stream_switch_task.cc
Unescape View File

@ -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;
}

1
src/ge/ge_runtime/task/task.h
Unescape View File

@ -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 {

10
src/ge/ge_runtime/task/tbe_task.cc
Unescape View File

@ -44,7 +44,7 @@ TbeTask::TbeTask(const ModelContext &model_context, const std::shared_ptr<TbeTas
TbeTask::~TbeTask() {
if (args_ != nullptr) {
rtError_t rt_ret = rtFree(args_);
if (rt_ret != RT_ERROR_NONE) {
if (rt_ret != ACL_RT_SUCCESS) {
GELOGE(RT_FAILED, "rtFree fwkOpBuf failed! ret: 0x%X.", rt_ret);
}
args_ = nullptr;
@ -64,7 +64,7 @@ bool TbeTask::Distribute() {
}
rtError_t rt_ret = rtGetFunctionByName(const_cast<char *>(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<int32_t>(rt_ret));
stub_func_ = nullptr;
return false;
@ -82,7 +82,7 @@ bool TbeTask::Distribute() {
auto args_size = static_cast<uint32_t>(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<int32_t>(rt_ret));
return false;
}
@ -90,7 +90,7 @@ bool TbeTask::Distribute() {
rt_ret = rtMemcpy(args_, args_size, reinterpret_cast<void *>(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;
}

21
third_party/fwkacllib/inc/register/op_tiling.h vendored
Unescape View File

@ -20,29 +20,12 @@
#include "graph/debug/ge_attr_define.h"
#include "graph/node.h"
#include "register/op_tiling_registry.h"
#include <nlohmann/json.hpp>
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<bool(const std::string &, const TeOpParas &, const nlohmann::json &, OpRunInfo &)>;
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_

130
third_party/fwkacllib/inc/register/op_tiling_registry.h vendored
Unescape View File

@ -19,93 +19,135 @@
#include <functional>
#include <map>
#include <nlohmann/json.hpp>
#include <sstream>
#include <string>
#include <vector>
#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<int64_t> shape;
std::vector<int64_t> ori_shape;
std::string format;
std::string ori_format;
std::string dtype;
std::map<std::string, std::string> attrs;
std::vector<int64_t> shape;
std::vector<int64_t> ori_shape;
std::string format;
std::string ori_format;
std::string dtype;
std::map<std::string, std::string> attrs;
};
struct TeOpTensorArg {
TensorArgType arg_type;
std::vector<TeOpTensor> tensor;
TensorArgType arg_type;
std::vector<TeOpTensor> tensor;
};
struct OpRunInfo {
uint32_t block_dim;
std::vector<int64_t> workspaces;
ByteBuffer tiling_data;
bool clear_atomic;
uint32_t block_dim;
std::vector<int64_t> workspaces;
ByteBuffer tiling_data;
bool clear_atomic;
};
using TeOpAttrArgs = std::vector<std::string>;
using TeConstTensorData = std::tuple<const uint8_t *, size_t, ge::Tensor>;
using TeConstTensorData = std::tuple<const uint8_t*, size_t, ge::Tensor>;
struct TeOpParas {
std::vector<TeOpTensorArg> inputs;
std::vector<TeOpTensorArg> outputs;
std::map<std::string, TeConstTensorData> const_inputs;
TeOpAttrArgs attrs;
std::string op_type;
std::vector<TeOpTensorArg> inputs;
std::vector<TeOpTensorArg> outputs;
std::map<std::string, TeConstTensorData> const_inputs;
TeOpAttrArgs attrs;
std::string op_type;
};
using OpTilingFunc = std::function<bool(const std::string&, const TeOpParas&,
const nlohmann::json& , OpRunInfo&)>;
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<std::string, OpTilingFunc> &RegisteredOpInterf();
static std::string OpTilingUuid;
};
struct OpCompileInfo {
std::string str;
std::string key;
std::string str;
std::string key;
};
using OpTilingFunc = std::function<bool(const TeOpParas &, const OpCompileInfo &, OpRunInfo &)>;
using OpTilingFuncNew = std::function<bool(const TeOpParas&, const OpCompileInfo& , OpRunInfo&)>;
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<std::string, OpTilingFunc> &RegisteredOpInterf();
public:
OpTilingRegistryInterf(std::string op_type, OpTilingFuncNew func);
~OpTilingRegistryInterf() = default;
static std::map<std::string, OpTilingFuncNew> &RegisteredOpInterf();
};
template <class T>
ByteBuffer &ByteBufferPut(ByteBuffer &buf, const T &value) {
buf.write(reinterpret_cast<const char *>(&value), sizeof(value));
buf.flush();
return buf;
ByteBuffer& ByteBufferPut(ByteBuffer &buf, const T &value)
{
buf.write(reinterpret_cast<const char*>(&value), sizeof(value));
buf.flush();
return buf;
}
template <class T>
ByteBuffer &ByteBufferGet(ByteBuffer &buf, T &value) {
buf.read(reinterpret_cast<char *>(&value), sizeof(value));
return buf;
ByteBuffer& ByteBufferGet(ByteBuffer &buf, T &value)
{
buf.read(reinterpret_cast<char*>(&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_

305
third_party/fwkacllib/inc/runtime/base.h vendored
View File

File diff suppressed because it is too large Load Diff
Write Preview
Loading…
Cancel
Save