diff --git a/ge/common/helper/model_helper.cc b/ge/common/helper/model_helper.cc index bb4502c7..ab5075e1 100644 --- a/ge/common/helper/model_helper.cc +++ b/ge/common/helper/model_helper.cc @@ -268,18 +268,18 @@ ModelHelper::SaveOriginalGraphToOmModel(const ge::Graph &graph, const std::strin FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::LoadModel(const ge::ModelData &model_data) { if (model_data.model_data == nullptr || model_data.model_len == 0) { - GELOGE(GE_EXEC_MODEL_DATA_SIZE_INVALID, "Model_data is nullptr, or model_data_size is 0"); - return GE_EXEC_MODEL_DATA_SIZE_INVALID; + GELOGE(ACL_ERROR_GE_EXEC_MODEL_DATA_SIZE_INVALID, "Model_data is nullptr, or model_data_size is 0"); + return ACL_ERROR_GE_EXEC_MODEL_DATA_SIZE_INVALID; } if (is_assign_model_) { - GELOGE(GE_EXEC_LOAD_MODEL_REPEATED, "Model helper has already loaded!"); - return GE_EXEC_LOAD_MODEL_REPEATED; + GELOGE(ACL_ERROR_GE_EXEC_LOAD_MODEL_REPEATED, "Model helper has already loaded!"); + return ACL_ERROR_GE_EXEC_LOAD_MODEL_REPEATED; } if (ReleaseLocalModelData() != SUCCESS) { - GELOGE(INTERNAL_ERROR, "ReleaseLocalModelData failed."); - return INTERNAL_ERROR; + GELOGE(ACL_ERROR_GE_EXEC_RELEASE_MODEL_DATA, "ReleaseLocalModelData failed."); + return ACL_ERROR_GE_EXEC_RELEASE_MODEL_DATA; } Status status = ge::DavinciModelParser::ParseModelContent(model_data, model_addr_tmp_, model_len_tmp_); @@ -300,8 +300,8 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::LoadModel(c auto partition_table = reinterpret_cast(model_addr_tmp_); if (partition_table->num == kOriginalOmPartitionNum) { model_addr_tmp_ = nullptr; - GELOGE(GE_EXEC_MODEL_PARTITION_NUM_INVALID, "om model is error,please use executable om model"); - return GE_EXEC_MODEL_PARTITION_NUM_INVALID; + GELOGE(ACL_ERROR_GE_EXEC_MODEL_PARTITION_NUM_INVALID, "om model is error,please use executable om model"); + return ACL_ERROR_GE_EXEC_MODEL_PARTITION_NUM_INVALID; } // Encrypt model need to del temp model/no encrypt model don't need to del model model_addr_tmp_ = nullptr; @@ -321,23 +321,23 @@ Status ModelHelper::GenerateGeModel(OmFileLoadHelper &om_load_helper) { GE_CHECK_NOTNULL(model_); Status ret = LoadModelData(om_load_helper); if (ret != SUCCESS) { - return GE_EXEC_LOAD_MODEL_PARTITION_FAILED; + return ACL_ERROR_GE_EXEC_LOAD_MODEL_PARTITION_FAILED; } ret = LoadWeights(om_load_helper); if (ret != SUCCESS) { - return GE_EXEC_LOAD_WEIGHT_PARTITION_FAILED; + return ACL_ERROR_GE_EXEC_LOAD_WEIGHT_PARTITION_FAILED; } ret = LoadTask(om_load_helper); if (ret != SUCCESS) { - return GE_EXEC_LOAD_TASK_PARTITION_FAILED; + return ACL_ERROR_GE_EXEC_LOAD_TASK_PARTITION_FAILED; } ret = LoadTBEKernelStore(om_load_helper); if (ret != SUCCESS) { - return GE_EXEC_LOAD_KERNEL_PARTITION_FAILED; + return ACL_ERROR_GE_EXEC_LOAD_KERNEL_PARTITION_FAILED; } ret = LoadCustAICPUKernelStore(om_load_helper); if (ret != SUCCESS) { - return GE_EXEC_LOAD_KERNEL_PARTITION_FAILED; + return ACL_ERROR_GE_EXEC_LOAD_KERNEL_PARTITION_FAILED; } return SUCCESS; } diff --git a/ge/common/helper/om_file_helper.cc b/ge/common/helper/om_file_helper.cc index 39cd7ad7..75140e9c 100644 --- a/ge/common/helper/om_file_helper.cc +++ b/ge/common/helper/om_file_helper.cc @@ -110,8 +110,8 @@ Status OmFileLoadHelper::CheckModelValid(const ge::ModelData &model) const { Status OmFileLoadHelper::LoadModelPartitionTable(uint8_t *model_data, const uint32_t model_data_size) { if (model_data == nullptr) { - GELOGE(PARAM_INVALID, "Param model_data must not be null!"); - return PARAM_INVALID; + GELOGE(ACL_ERROR_GE_EXEC_MODEL_ADDR_INVALID, "Param model_data must not be null!"); + return ACL_ERROR_GE_EXEC_MODEL_ADDR_INVALID; } // Init partition table auto partition_table = reinterpret_cast(model_data); @@ -119,16 +119,16 @@ Status OmFileLoadHelper::LoadModelPartitionTable(uint8_t *model_data, const uint // Original model partition include graph-info if ((partition_table->num != PARTITION_SIZE) && (partition_table->num != (PARTITION_SIZE - 1)) && (partition_table->num != (PARTITION_SIZE - kOptionalNum)) && (partition_table->num != 1)) { - GELOGE(GE_EXEC_MODEL_PARTITION_NUM_INVALID, "Invalid partition_table->num:%u", partition_table->num); - return GE_EXEC_MODEL_PARTITION_NUM_INVALID; + GELOGE(ACL_ERROR_GE_EXEC_MODEL_PARTITION_NUM_INVALID, "Invalid partition_table->num:%u", partition_table->num); + return ACL_ERROR_GE_EXEC_MODEL_PARTITION_NUM_INVALID; } size_t mem_offset = SIZE_OF_MODEL_PARTITION_TABLE(*partition_table); GELOGI("ModelPartitionTable num :%u, ModelFileHeader length :%zu, ModelPartitionTable length :%zu", partition_table->num, sizeof(ModelFileHeader), mem_offset); if (model_data_size <= mem_offset) { - GELOGE(GE_EXEC_MODEL_DATA_SIZE_INVALID, "invalid model data, partition_table->num:%u, model data size %u", + GELOGE(ACL_ERROR_GE_EXEC_MODEL_DATA_SIZE_INVALID, "invalid model data, partition_table->num:%u, model data size %u", partition_table->num, model_data_size); - return GE_EXEC_MODEL_DATA_SIZE_INVALID; + return ACL_ERROR_GE_EXEC_MODEL_DATA_SIZE_INVALID; } for (uint32_t i = 0; i < partition_table->num; i++) { ModelPartition partition; @@ -138,9 +138,9 @@ Status OmFileLoadHelper::LoadModelPartitionTable(uint8_t *model_data, const uint context_.partition_datas_.push_back(partition); if (partition.size > model_data_size || mem_offset > model_data_size - partition.size) { - GELOGE(GE_EXEC_MODEL_DATA_SIZE_INVALID, "The partition size %zu is greater than the model data size %u.", + GELOGE(ACL_ERROR_GE_EXEC_MODEL_DATA_SIZE_INVALID, "The partition size %zu is greater than the model data size %u.", partition.size + mem_offset, model_data_size); - return GE_EXEC_MODEL_DATA_SIZE_INVALID; + return ACL_ERROR_GE_EXEC_MODEL_DATA_SIZE_INVALID; } mem_offset += partition.size; GELOGI("Partition, type:%d, size:%u", static_cast(partition.type), partition.size); diff --git a/ge/common/model_parser/base.cc b/ge/common/model_parser/base.cc index 8478aebe..25cc6645 100644 --- a/ge/common/model_parser/base.cc +++ b/ge/common/model_parser/base.cc @@ -36,18 +36,18 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelParserBase::LoadFro std::string real_path = RealPath(model_path); if (real_path.empty()) { GELOGE(GE_EXEC_MODEL_PATH_INVALID, "Model file path '%s' is invalid", model_path); - return GE_EXEC_MODEL_PATH_INVALID; + return ACL_ERROR_GE_EXEC_MODEL_PATH_INVALID; } if (GetFileLength(model_path) == -1) { - GELOGE(GE_EXEC_READ_MODEL_FILE_FAILED, "File size not valid, file: %s.", model_path); - return GE_EXEC_READ_MODEL_FILE_FAILED; + GELOGE(ACL_ERROR_GE_EXEC_MODEL_PATH_INVALID, "File size not valid, file: %s.", model_path); + return ACL_ERROR_GE_EXEC_MODEL_PATH_INVALID; } std::ifstream fs(real_path.c_str(), std::ifstream::binary); if (!fs.is_open()) { - GELOGE(GE_EXEC_READ_MODEL_FILE_FAILED, "Open file: %s failed, error: %s", model_path, strerror(errno)); - return GE_EXEC_READ_MODEL_FILE_FAILED; + GELOGE(ACL_ERROR_GE_EXEC_MODEL_PATH_INVALID, "Open file: %s failed, error: %s", model_path, strerror(errno)); + return ACL_ERROR_GE_EXEC_MODEL_PATH_INVALID; } // get length of file: @@ -60,8 +60,8 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelParserBase::LoadFro char *data = new (std::nothrow) char[len]; if (data == nullptr) { - GELOGE(MEMALLOC_FAILED, "Load model From file failed, bad memory allocation occur. (need:%u)", len); - return MEMALLOC_FAILED; + GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "Load model From file failed, bad memory allocation occur. (need:%u)", len); + return ACL_ERROR_GE_MEMORY_ALLOCATION; } // read data as a block: @@ -84,7 +84,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelParserBase::ParseMo GE_CHECK_NOTNULL(model.model_data); // Model length too small - GE_CHK_BOOL_RET_STATUS(model.model_len >= sizeof(ModelFileHeader), GE_EXEC_MODEL_DATA_SIZE_INVALID, + GE_CHK_BOOL_RET_STATUS(model.model_len >= sizeof(ModelFileHeader), ACL_ERROR_GE_EXEC_MODEL_DATA_SIZE_INVALID, "Invalid model. Model data size %u must be greater than or equal to %zu.", model.model_len, sizeof(ModelFileHeader)); // Get file header @@ -92,7 +92,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelParserBase::ParseMo // Determine whether the file length and magic number match GE_CHK_BOOL_RET_STATUS( file_header->length == model.model_len - sizeof(ModelFileHeader) && file_header->magic == MODEL_FILE_MAGIC_NUM, - GE_EXEC_MODEL_DATA_SIZE_INVALID, + ACL_ERROR_GE_EXEC_MODEL_DATA_SIZE_INVALID, "Invalid model. file_header->length[%u] + sizeof(ModelFileHeader)[%zu] != model->model_len[%u] || " "MODEL_FILE_MAGIC_NUM[%u] != file_header->magic[%u]", file_header->length, sizeof(ModelFileHeader), model.model_len, MODEL_FILE_MAGIC_NUM, file_header->magic); @@ -102,15 +102,15 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelParserBase::ParseMo // Get data address uint8_t *data = reinterpret_cast(model.model_data) + sizeof(ModelFileHeader); if (file_header->is_encrypt == ModelEncryptType::UNENCRYPTED) { // Unencrypted model - GE_CHK_BOOL_RET_STATUS(model.key.empty(), GE_EXEC_MODEL_NOT_SUPPORT_ENCRYPTION, + GE_CHK_BOOL_RET_STATUS(model.key.empty(), ACL_ERROR_GE_EXEC_MODEL_NOT_SUPPORT_ENCRYPTION, "Invalid param. model is unencrypted, but key is not empty."); model_data = data; model_len = file_header->length; GELOGI("Model_len is %u, model_file_head_len is %zu.", model_len, sizeof(ModelFileHeader)); } else { - GELOGE(GE_EXEC_MODEL_NOT_SUPPORT_ENCRYPTION, "Invalid model. ModelEncryptType not supported."); - res = GE_EXEC_MODEL_NOT_SUPPORT_ENCRYPTION; + GELOGE(ACL_ERROR_GE_EXEC_MODEL_NOT_SUPPORT_ENCRYPTION, "Invalid model. ModelEncryptType not supported."); + res = ACL_ERROR_GE_EXEC_MODEL_NOT_SUPPORT_ENCRYPTION; } return res; diff --git a/ge/executor/ge_executor.cc b/ge/executor/ge_executor.cc index 967bf420..c7836174 100755 --- a/ge/executor/ge_executor.cc +++ b/ge/executor/ge_executor.cc @@ -50,19 +50,6 @@ const size_t kDynamicImageSizeVecSize = 2; const size_t kDynamicImageSizeInputSize = 2; const char *const kBatchLabel = "Batch_"; -ge::Status TransferDomiErrorCode(const uint32_t errorCode) { - switch (errorCode) { - case ge::PARAM_INVALID: - case domi::PARAM_INVALID: - return ge::PARAM_INVALID; - case ge::INTERNAL_ERROR: - case domi::INTERNAL_ERROR: - return ge::INTERNAL_ERROR; - default: - return ge::FAILED; - } -} - void GetGeTensorDescFromDomiInfo(std::vector &ge_descs, const std::vector &domi_descs, const std::vector &formats) { @@ -286,14 +273,14 @@ Status GeExecutor::Finalize() { Status GeExecutor::SetDynamicBatchSize(uint32_t model_id, void *dynamic_input_addr, uint64_t length, uint64_t batch_size) { if (dynamic_input_addr == nullptr) { - GELOGE(PARAM_INVALID, "Dynamic input addr is nullptr!"); - return PARAM_INVALID; + GELOGE(ACL_ERROR_GE_DYNAMIC_INPUT_ADDR_INVALID, "Dynamic input addr is nullptr!"); + return ACL_ERROR_GE_DYNAMIC_INPUT_ADDR_INVALID; } uint64_t size = sizeof(uint32_t); if (length < size) { - GELOGE(PARAM_INVALID, "Dynamic input size [%lu] is less than [%lu]!", length, size); - return PARAM_INVALID; + GELOGE(ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID, "Dynamic input size [%lu] is less than [%lu]!", length, size); + return ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID; } if (length >= sizeof(uint64_t)) { size = sizeof(uint64_t); @@ -310,8 +297,8 @@ Status GeExecutor::SetDynamicBatchSize(uint32_t model_id, void *dynamic_input_ad } if (!IsDynamicBatchSizeMatchModel(batch_size, batch_info)) { - GELOGE(PARAM_INVALID, "The current dynamic input does not match the gear of the model."); - return PARAM_INVALID; + GELOGE(ACL_ERROR_GE_DYNAMIC_BATCH_SIZE_INVALID, "The current dynamic input does not match the gear of the model."); + return ACL_ERROR_GE_DYNAMIC_BATCH_SIZE_INVALID; } ret = GraphExecutor::SetDynamicSize(model_id, batch_num, static_cast(DYNAMIC_BATCH)); @@ -322,7 +309,7 @@ Status GeExecutor::SetDynamicBatchSize(uint32_t model_id, void *dynamic_input_ad // memcpy dynamic_batch_size from host to device rtError_t rt_ret = rtMemcpy(dynamic_input_addr, length, &batch_size, size, RT_MEMCPY_HOST_TO_DEVICE); if (rt_ret != RT_ERROR_NONE) { - GELOGE(RT_FAILED, "memcpy dynamic batch input data failed! ret: 0x%X", rt_ret); + GELOGE(rt_ret, "memcpy dynamic batch input data failed! ret: 0x%X", rt_ret); return RT_ERROR_TO_GE_STATUS(rt_ret); } return SUCCESS; @@ -331,14 +318,15 @@ Status GeExecutor::SetDynamicBatchSize(uint32_t model_id, void *dynamic_input_ad Status GeExecutor::SetDynamicImageSize(uint32_t model_id, void *dynamic_input_addr, uint64_t length, uint64_t image_height, uint64_t image_width) { if (dynamic_input_addr == nullptr) { - GELOGE(PARAM_INVALID, "Dynamic input addr is nullptr!"); - return PARAM_INVALID; + GELOGE(ACL_ERROR_GE_DYNAMIC_INPUT_ADDR_INVALID, "Dynamic input addr is nullptr!"); + return ACL_ERROR_GE_DYNAMIC_INPUT_ADDR_INVALID; } uint64_t dynamic_input_size = kDynamicImageSizeInputSize * sizeof(uint32_t); if (length < dynamic_input_size) { - GELOGE(PARAM_INVALID, "Dynamic input size [%lu] is less than [%lu]!", length, dynamic_input_size); - return PARAM_INVALID; + GELOGE(ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID, + "Dynamic input size [%lu] is less than [%lu]!", length, dynamic_input_size); + return ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID; } uint64_t size = sizeof(uint32_t); if (length >= kDynamicImageSizeInputSize * sizeof(uint64_t)) { @@ -355,8 +343,8 @@ Status GeExecutor::SetDynamicImageSize(uint32_t model_id, void *dynamic_input_ad } if (!IsDynamicImageSizeMatchModel(image_height, image_width, batch_info)) { - GELOGE(PARAM_INVALID, "The current dynamic input does not match the gear of the model."); - return PARAM_INVALID; + GELOGE(ACL_ERROR_GE_DYNAMIC_BATCH_SIZE_INVALID, "The current dynamic input does not match the gear of the model."); + return ACL_ERROR_GE_DYNAMIC_BATCH_SIZE_INVALID; } ret = GraphExecutor::SetDynamicSize(model_id, batch_num, static_cast(DYNAMIC_IMAGE)); @@ -365,20 +353,21 @@ Status GeExecutor::SetDynamicImageSize(uint32_t model_id, void *dynamic_input_ad return ret; } - // Memcpy dynamic resolution height from host to device + // Memcpy dynamic resolution height from host to device rtError_t rt_ret = rtMemcpy(dynamic_input_addr, size, &image_height, size, RT_MEMCPY_HOST_TO_DEVICE); if (rt_ret != RT_ERROR_NONE) { - GELOGE(RT_FAILED, "memcpy dynamic resolution input data failed! ret: 0x%X", rt_ret); + GELOGE(rt_ret, "memcpy dynamic resolution input data failed! ret: 0x%X", rt_ret); return RT_ERROR_TO_GE_STATUS(rt_ret); } uint64_t remain_size = length - size; // Memcpy dynamic resolution width from host to device - if (rtMemcpy(reinterpret_cast(reinterpret_cast(dynamic_input_addr) + size), - remain_size, &image_width, size, RT_MEMCPY_HOST_TO_DEVICE) != RT_ERROR_NONE) { - GELOGE(FAILED, "memcpy dynamic resolution input data failed!"); - return FAILED; + rt_ret = rtMemcpy(reinterpret_cast(reinterpret_cast(dynamic_input_addr) + size), + remain_size, &image_width, size, RT_MEMCPY_HOST_TO_DEVICE); + if (rt_ret != RT_ERROR_NONE) { + GELOGE(rt_ret, "memcpy dynamic resolution input data failed!"); + return RT_ERROR_TO_GE_STATUS(rt_ret); } return SUCCESS; } @@ -386,15 +375,15 @@ Status GeExecutor::SetDynamicImageSize(uint32_t model_id, void *dynamic_input_ad Status GeExecutor::SetDynamicDims(uint32_t model_id, void *dynamic_input_addr, uint64_t length, const vector &dynamic_dims) { if (dynamic_input_addr == nullptr) { - GELOGE(FAILED, "Dynamic input addr is nullptr!"); - return FAILED; + GELOGE(ACL_ERROR_GE_DYNAMIC_INPUT_ADDR_INVALID, "Dynamic input addr is nullptr!"); + return ACL_ERROR_GE_DYNAMIC_INPUT_ADDR_INVALID; } vector cur_dynamic_dims; Status ret = GetCurDynamicDims(model_id, dynamic_dims, cur_dynamic_dims); if (ret != SUCCESS) { - GELOGE(FAILED, "Set cur gear dynamic dims failed"); - return FAILED; + GELOGE(ret, "Set cur gear dynamic dims failed"); + return ret; } std::vector> batch_info; int32_t dynamic_type = static_cast(FIXED); @@ -405,32 +394,35 @@ Status GeExecutor::SetDynamicDims(uint32_t model_id, void *dynamic_input_addr, u } if (!IsDynmaicDimsSizeMatchModel(cur_dynamic_dims, batch_info)) { - GELOGE(PARAM_INVALID, "The current dynamic input does not match the gear of the model."); - return PARAM_INVALID; + GELOGE(ACL_ERROR_GE_DYNAMIC_BATCH_SIZE_INVALID, "The current dynamic input does not match the gear of the model."); + return ACL_ERROR_GE_DYNAMIC_BATCH_SIZE_INVALID; } ret = GraphExecutor::SetDynamicSize(model_id, cur_dynamic_dims, static_cast(DYNAMIC_DIMS)); if (ret != SUCCESS) { - GELOGE(FAILED, "Set dynamic size failed"); - return FAILED; + GELOGE(ret, "Set dynamic size failed"); + return ret; } size_t dynamic_dim_num = cur_dynamic_dims.size(); uint64_t dynamic_input_size = static_cast(dynamic_dim_num * sizeof(uint32_t)); if (length < dynamic_input_size) { - GELOGE(FAILED, "Dynamic input size [%lu] is less than [%lu]!", length, dynamic_input_size); - return FAILED; + GELOGE(ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID, + "Dynamic input size [%lu] is less than [%lu]!", length, dynamic_input_size); + return ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID; } uint64_t size = sizeof(uint32_t); if (length >= dynamic_dim_num * sizeof(uint64_t)) { size = sizeof(uint64_t); } + rtError_t rt_ret; for (uint32_t i = 0; i < dynamic_dim_num; ++i) { // Memcpy dynamic dim[i] from host to device - if (rtMemcpy(reinterpret_cast(reinterpret_cast(dynamic_input_addr) + size * i), - length - size * i, &cur_dynamic_dims[i], size, RT_MEMCPY_HOST_TO_DEVICE) != RT_ERROR_NONE) { - GELOGE(FAILED, "memcpy dynamic resolution input data failed!"); - return FAILED; + rt_ret = rtMemcpy(reinterpret_cast(reinterpret_cast(dynamic_input_addr) + size * i), + length - size * i, &cur_dynamic_dims[i], size, RT_MEMCPY_HOST_TO_DEVICE); + if (rt_ret != RT_ERROR_NONE) { + GELOGE(rt_ret, "memcpy dynamic resolution input data failed!"); + return RT_ERROR_TO_GE_STATUS(rt_ret); } } return SUCCESS; @@ -443,15 +435,15 @@ Status GeExecutor::GetCurDynamicDims(uint32_t model_id, const vector & vector output_desc; auto ret = GetModelDescInfo(model_id, input_desc, output_desc); if (ret != ge::SUCCESS) { - GELOGE(FAILED, "GetModelDescInfo failed."); - return FAILED; + GELOGE(ret, "GetModelDescInfo failed."); + return ret; } vector user_designate_shape_order; vector all_data_dims; ret = GetUserDesignateShapeOrder(model_id, user_designate_shape_order); if (ret != ge::SUCCESS) { - GELOGE(FAILED, "GetUserDesignateShapeOrder failed."); - return FAILED; + GELOGE(ret, "GetUserDesignateShapeOrder failed."); + return ret; } for (auto &data_name : user_designate_shape_order) { for (auto &desc : input_desc) { @@ -464,17 +456,18 @@ Status GeExecutor::GetCurDynamicDims(uint32_t model_id, const vector & } } if (dynamic_dims.size() != all_data_dims.size()){ - GELOGE(FAILED, "Dynamic input size [%lu] is not equal with all data dims size [%lu]!", + GELOGE(ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID, + "Dynamic input size [%lu] is not equal with all data dims size [%lu]!", dynamic_dims.size(), all_data_dims.size()); - return FAILED; + return ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID; } for (std::size_t i = 0; i < all_data_dims.size(); ++i) { if (all_data_dims[i] < 0) { cur_dynamic_dims.push_back(dynamic_dims[i]); } else if (static_cast(all_data_dims[i]) != dynamic_dims[i]) { - GELOGE(PARAM_INVALID, "Static dims should be same, index: %zu value: %d should be %d", + GELOGE(ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID, "Static dims should be same, index: %zu value: %d should be %d", i, dynamic_dims[i], all_data_dims[i]); - return PARAM_INVALID; + return ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID; } } return SUCCESS; @@ -483,8 +476,8 @@ Status GeExecutor::GetCurDynamicDims(uint32_t model_id, const vector & Status GeExecutor::GetCurShape(const uint32_t model_id, std::vector &batch_info, int32_t &dynamic_type) { GELOGI("Begin to get current shape"); if (!isInit_) { - GELOGE(GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); - return GE_EXEC_NOT_INIT; + GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); + return ACL_ERROR_GE_EXEC_NOT_INIT; } Status ret = GraphExecutor::GetCurShape(model_id, batch_info, dynamic_type); if (ret != SUCCESS) { @@ -499,12 +492,12 @@ Status GeExecutor::SetDynamicAippData(uint32_t model_id, void *dynamic_input_add const kAippDynamicPara &aippParms) { GELOGI("Enter to SetDynamicAippData."); if (dynamic_input_addr == nullptr) { - GELOGE(PARAM_INVALID, "Dynamic aipp input addr is nullptr!"); - return PARAM_INVALID; + GELOGE(ACL_ERROR_GE_DYNAMIC_INPUT_ADDR_INVALID, "Dynamic aipp input addr is nullptr!"); + return ACL_ERROR_GE_DYNAMIC_INPUT_ADDR_INVALID; } if (aippBatchPara.empty()) { - GELOGE(PARAM_INVALID, "aippBatchPara is empty."); - return PARAM_INVALID; + GELOGE(ACL_ERROR_GE_AIPP_BATCH_EMPTY, "aippBatchPara is empty."); + return ACL_ERROR_GE_AIPP_BATCH_EMPTY; } uint64_t batch_num = aippBatchPara.size(); uint64_t real_aippParms_size = sizeof(kAippDynamicPara) - sizeof(kAippDynamicBatchPara); @@ -514,13 +507,14 @@ Status GeExecutor::SetDynamicAippData(uint32_t model_id, void *dynamic_input_add "batch num is %lu, struct_len is %lu", model_id, length, batch_num, struct_len); if (struct_len > length) { - GELOGE(PARAM_INVALID, "input dynamic aipp param len [%lu] is larger than aipp_data size [%lu]", struct_len, length); - return PARAM_INVALID; + GELOGE(ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID, + "input dynamic aipp param len [%lu] is larger than aipp_data size [%lu]", struct_len, length); + return ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID; } // Memcpy real kAippDynamicBatchPara from host to device rtError_t rt_ret = rtMemcpy(dynamic_input_addr, length, &aippParms, real_aippParms_size, RT_MEMCPY_HOST_TO_DEVICE); if (rt_ret != RT_ERROR_NONE) { - GELOGE(RT_FAILED, "memcpy real_aippParms_size failed! ret: 0x%X", rt_ret); + GELOGE(rt_ret, "memcpy real_aippParms_size failed! ret: 0x%X", rt_ret); return RT_ERROR_TO_GE_STATUS(rt_ret); } uint64_t remain_len = length - real_aippParms_size; @@ -531,7 +525,7 @@ Status GeExecutor::SetDynamicAippData(uint32_t model_id, void *dynamic_input_add (remain_len - i * sizeof(kAippDynamicBatchPara)), &(aippBatchPara[i]), sizeof(kAippDynamicBatchPara), RT_MEMCPY_HOST_TO_DEVICE); if (rt_ret != RT_ERROR_NONE) { - GELOGE(RT_FAILED, "memcpy kAippDynamicBatchPara input data failed! ret: 0x%X", rt_ret); + GELOGE(rt_ret, "memcpy kAippDynamicBatchPara input data failed! ret: 0x%X", rt_ret); return RT_ERROR_TO_GE_STATUS(rt_ret); } } @@ -543,27 +537,28 @@ Status GeExecutor::LoadModelOffline(uint32_t &model_id, const std::string &path, int32_t priority, std::shared_ptr listener) { GELOGI("load model offline begin."); if (!isInit_) { - GELOGE(GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); - return GE_EXEC_NOT_INIT; + GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); + return ACL_ERROR_GE_EXEC_NOT_INIT; } string filePath = RealPath(path.c_str()); if (filePath.empty()) { - GELOGE(ge::FAILED, "File path is invalid. please check your text file '%s'.", path.c_str()); - return ge::FAILED; + GELOGE(ACL_ERROR_GE_EXEC_MODEL_PATH_INVALID, + "File path is invalid. please check your text file '%s'.", path.c_str()); + return ACL_ERROR_GE_EXEC_MODEL_PATH_INVALID; } std::shared_ptr listener_adapter = MakeShared(); if (listener_adapter == nullptr) { - GELOGE(MEMALLOC_FAILED, "ModelListenerAdapter make shared failed!"); - return ge::FAILED; + GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "ModelListenerAdapter make shared failed!"); + return ACL_ERROR_GE_MEMORY_ALLOCATION; } listener_adapter->listener = listener; Status ret = GraphLoader::LoadModelFromFile(path, key, priority, listener_adapter, model_id); if (ret != SUCCESS) { GELOGE(ret, "[GeExecutor] LoadModelFromFile failed"); - return TransferDomiErrorCode(ret); + return ACL_ERROR_GE_LOAD_MODEL; } return SUCCESS; } @@ -572,21 +567,21 @@ Status GeExecutor::LoadModel(uint32_t &model_id, const ModelData &model_data, std::shared_ptr listener) { GELOGI("Load model begin."); if (!isInit_) { - GELOGE(GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); - return GE_EXEC_NOT_INIT; + GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); + return ACL_ERROR_GE_EXEC_NOT_INIT; } std::shared_ptr listener_adapter = MakeShared(); if (listener_adapter == nullptr) { - GELOGE(MEMALLOC_FAILED, "ModelListenerAdapter make shared failed!"); - return ge::FAILED; + GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "ModelListenerAdapter make shared failed!"); + return ACL_ERROR_GE_MEMORY_ALLOCATION; } listener_adapter->listener = listener; Status ret = GraphLoader::LoadModel(model_data, listener_adapter, model_id); if (ret != SUCCESS) { GELOGE(ret, "[GeExecutor] LoadModel failed."); - return TransferDomiErrorCode(ret); + return ACL_ERROR_GE_LOAD_MODEL; } return ret; } @@ -594,13 +589,13 @@ Status GeExecutor::LoadModel(uint32_t &model_id, const ModelData &model_data, Status GeExecutor::UnloadModel(uint32_t model_id) { GELOGI("unload model %u begin.", model_id); if (!isInit_) { - GELOGE(GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); - return GE_EXEC_NOT_INIT; + GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); + return ACL_ERROR_GE_EXEC_NOT_INIT; } Status ret = GraphLoader::DestroyAicpuSessionForInfer(model_id); if (ret != SUCCESS) { GELOGE(ret, "[GraphLoader] DestroyAicpuSessionForInfer failed. model id: %u", model_id); - return FAILED; + return ACL_ERROR_GE_INTERNAL_ERROR; } std::shared_ptr davinci_model = ModelManager::GetInstance()->GetModel(model_id); @@ -608,14 +603,19 @@ Status GeExecutor::UnloadModel(uint32_t model_id) { uint64_t session_id = davinci_model->GetSessionId(); VarManagerPool::Instance().RemoveVarManager(session_id); } - return GraphLoader::UnloadModel(model_id); + ret = GraphLoader::UnloadModel(model_id); + if (ret != SUCCESS) { + GELOGE(ret, "[GraphLoader] DestroyAicpuSessionForInfer failed. model id: %u", model_id); + return ACL_ERROR_GE_UNLOAD_MODEL; + } + return SUCCESS; } Status GeExecutor::RunModel(const ge::RunModelData &input_data, ge::RunModelData &output_data) { GELOGI("run model begin."); if (!isInit_) { - GELOGE(GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); - return GE_EXEC_NOT_INIT; + GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); + return ACL_ERROR_GE_EXEC_NOT_INIT; } InputData inputs; @@ -631,8 +631,8 @@ Status GeExecutor::GetModelDescInfo(uint32_t model_id, std::vector &output_desc, bool new_model_desc) { GELOGI("get model desc info begin."); if (!isInit_) { - GELOGE(GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); - return GE_EXEC_NOT_INIT; + GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); + return ACL_ERROR_GE_EXEC_NOT_INIT; } std::vector input_desc_infos; @@ -644,19 +644,20 @@ Status GeExecutor::GetModelDescInfo(uint32_t model_id, std::vector> &batch_info) { GELOGI("Begin to get combined dynamic dims info."); if (!isInit_) { - GELOGE(GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); - return GE_EXEC_NOT_INIT; + GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); + return ACL_ERROR_GE_EXEC_NOT_INIT; } Status ret = GraphExecutor::GetCombinedDynamicDims(model_id, batch_info); @@ -727,8 +728,8 @@ Status GeExecutor::GetCombinedDynamicDims(uint32_t model_id, vector &user_designate_shape_order) { GELOGI("Begin to get user designate shape info."); if (!isInit_) { - GELOGE(GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); - return GE_EXEC_NOT_INIT; + GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); + return ACL_ERROR_GE_EXEC_NOT_INIT; } Status ret = GraphExecutor::GetUserDesignateShapeOrder(model_id, user_designate_shape_order); @@ -752,8 +753,8 @@ Status GeExecutor::GetUserDesignateShapeOrder(uint32_t model_id, vector Status GeExecutor::GetAIPPInfo(uint32_t model_id, uint32_t index, AippConfigInfo &aipp_info) { GELOGI("Begin to GetAIPPInfo."); if (!isInit_) { - GELOGE(GE_EXEC_NOT_INIT, "not inited yet!"); - return GE_EXEC_NOT_INIT; + GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "not inited yet!"); + return ACL_ERROR_GE_EXEC_NOT_INIT; } Status ret = GraphExecutor::GetAIPPInfo(model_id, index, aipp_info); if (ret != SUCCESS) { @@ -767,8 +768,8 @@ Status GeExecutor::GetAIPPInfo(uint32_t model_id, uint32_t index, AippConfigInfo Status GeExecutor::GetAippType(uint32_t model_id, uint32_t index, InputAippType &type, size_t &aipp_index) { GELOGI("Begin to get aipp type."); if (!isInit_) { - GELOGE(GE_EXEC_NOT_INIT, "not inited yet!"); - return GE_EXEC_NOT_INIT; + GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "not inited yet!"); + return ACL_ERROR_GE_EXEC_NOT_INIT; } Status ret = GraphExecutor::GetAippType(model_id, index, type, aipp_index); if (ret != SUCCESS) { @@ -782,8 +783,8 @@ Status GeExecutor::GetAippType(uint32_t model_id, uint32_t index, InputAippType Status GeExecutor::GetModelAttr(uint32_t model_id, std::vector &dynamic_output_shape_info) { GELOGI("Begin to get dynamic batch output shape info"); if (!isInit_) { - GELOGE(GE_EXEC_NOT_INIT, "not inited yet!"); - return GE_EXEC_NOT_INIT; + GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "not inited yet!"); + return ACL_ERROR_GE_EXEC_NOT_INIT; } Status ret = GraphExecutor::GetModelAttr(model_id, dynamic_output_shape_info); if (ret != SUCCESS) { @@ -799,8 +800,8 @@ Status GeExecutor::GetModelDescInfoForZeroCopy(uint32_t model_id, std::vector &output_desc) { GELOGI("get model desc info for zero copy begin."); if (!isInit_) { - GELOGE(GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); - return GE_EXEC_NOT_INIT; + GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); + return ACL_ERROR_GE_EXEC_NOT_INIT; } std::vector input_desc_infos; @@ -812,17 +813,17 @@ Status GeExecutor::GetModelDescInfoForZeroCopy(uint32_t model_id, std::vector &output_queue_ids) { GELOGI("Load model with queue begin."); if (!isInit_) { - GELOGE(GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); - return GE_EXEC_NOT_INIT; + GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); + return ACL_ERROR_GE_EXEC_NOT_INIT; } return GraphLoader::LoadModelWithQ(model_id, model_data, input_queue_ids, output_queue_ids); } @@ -944,8 +946,8 @@ Status GeExecutor::ExecModel(uint32_t model_id, void *stream, const ge::RunModel ge::RunModelData &run_output_data, bool async_mode) { GELOGI("Execute model begin."); if (!isInit_) { - GELOGE(GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); - return GE_EXEC_NOT_INIT; + GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); + return ACL_ERROR_GE_EXEC_NOT_INIT; } InputData input_data; @@ -981,8 +983,8 @@ Status GeExecutor::ExecModel(uint32_t model_id, void *stream, const ge::RunModel Status GeExecutor::GetMemAndWeightSize(const std::string &path, size_t &mem_size, size_t &weight_size) { GELOGI("Get memory and weight size from file begin."); if (!isInit_) { - GELOGE(GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); - return GE_EXEC_NOT_INIT; + GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); + return ACL_ERROR_GE_EXEC_NOT_INIT; } ModelData model; @@ -1014,13 +1016,13 @@ Status GeExecutor::GetMemAndWeightSize(const void *model_data, size_t model_size size_t &weight_size) { GELOGI("Get memory and weight size from data begin."); if (!isInit_) { - GELOGE(GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); - return GE_EXEC_NOT_INIT; + GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); + return ACL_ERROR_GE_EXEC_NOT_INIT; } if (model_data == nullptr) { - GELOGE(PARAM_INVALID, "invalid model data!"); - return PARAM_INVALID; + GELOGE(ACL_ERROR_GE_EXEC_MODEL_ADDR_INVALID, "invalid model data!"); + return ACL_ERROR_GE_EXEC_MODEL_ADDR_INVALID; } ModelData model; @@ -1043,8 +1045,8 @@ Status GeExecutor::LoadDynamicSingleOp(const std::string &model_name, const ge:: Status GeExecutor::ExecuteAsync(SingleOp *executor, const std::vector &inputs, std::vector &outputs) { if (executor == nullptr) { - GELOGE(PARAM_INVALID, "param is NULL"); - return PARAM_INVALID; + GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "param is NULL"); + return ACL_ERROR_GE_EXEC_NOT_INIT; } return executor->ExecuteAsync(inputs, outputs); @@ -1067,8 +1069,8 @@ Status GeExecutor::GetDeviceIdByModelId(uint32_t model_id, uint32_t &device_id) GE_CHECK_NOTNULL(model_manager); auto davinci_model = model_manager->GetModel(model_id); if (davinci_model == nullptr) { - GELOGE(FAILED, "Model id: %d is invaild or model is not loaded.", model_id); - return FAILED; + GELOGE(ACL_ERROR_GE_EXEC_MODEL_ID_INVALID, "Model id: %d is invaild or model is not loaded.", model_id); + return ACL_ERROR_GE_EXEC_MODEL_ID_INVALID; } device_id = davinci_model->GetDeviceId(); @@ -1094,8 +1096,8 @@ Status GeExecutor::GetBatchInfoSize(uint32_t model_id, size_t &shape_count) { Status GeExecutor::GetOrigInputInfo(uint32_t model_id, uint32_t index, OriginInputInfo &orig_input_info) { GELOGI("Begin to GetOrigInputInfo."); if (!isInit_) { - GELOGE(GE_EXEC_NOT_INIT, "not inited yet!"); - return GE_EXEC_NOT_INIT; + GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "not inited yet!"); + return ACL_ERROR_GE_EXEC_NOT_INIT; } Status ret = GraphExecutor::GetOrigInputInfo(model_id, index, orig_input_info); @@ -1113,8 +1115,8 @@ Status GeExecutor::GetAllAippInputOutputDims(uint32_t model_id, uint32_t index, std::vector &output_dims) { GELOGI("Begin to GetAllAippInputOutputDims."); if (!isInit_) { - GELOGE(GE_EXEC_NOT_INIT, "not inited yet!"); - return GE_EXEC_NOT_INIT; + GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "not inited yet!"); + return ACL_ERROR_GE_EXEC_NOT_INIT; } Status ret = GraphExecutor::GetAllAippInputOutputDims(model_id, index, input_dims, output_dims); diff --git a/ge/graph/execute/graph_execute.cc b/ge/graph/execute/graph_execute.cc index 052d20a0..6907e7a6 100755 --- a/ge/graph/execute/graph_execute.cc +++ b/ge/graph/execute/graph_execute.cc @@ -91,7 +91,7 @@ Status GraphExecutor::SetDynamicSize(uint32_t model_id, const std::vectorSetDynamicSize(model_id, batch_num, dynamic_type); if (ret != SUCCESS) { - GELOGE(FAILED, "SetDynamicSize failed"); + GELOGE(ret, "SetDynamicSize failed"); return ret; } return SUCCESS; diff --git a/ge/graph/load/graph_loader.cc b/ge/graph/load/graph_loader.cc index cffd07e5..c7a572d4 100755 --- a/ge/graph/load/graph_loader.cc +++ b/ge/graph/load/graph_loader.cc @@ -212,9 +212,9 @@ Status GraphLoader::CommandHandle(const Command &command) { return ret; } } catch (std::bad_alloc &) { - GELOGE(MEMALLOC_FAILED, "Command handle failed, bad memory allocation occur !"); + GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "Command handle failed, bad memory allocation occur !"); - return MEMALLOC_FAILED; + return ACL_ERROR_GE_MEMORY_ALLOCATION; } catch (...) { GELOGE(FAILED, "Command handle failed, some exceptions occur !"); diff --git a/ge/graph/load/new_model_manager/davinci_model.cc b/ge/graph/load/new_model_manager/davinci_model.cc index 02b16158..9de152b7 100755 --- a/ge/graph/load/new_model_manager/davinci_model.cc +++ b/ge/graph/load/new_model_manager/davinci_model.cc @@ -1502,8 +1502,8 @@ Status DavinciModel::InitVariable(const OpDescPtr &op_desc) { Status DavinciModel::SetQueIds(const std::vector &input_queue_ids, const std::vector &output_queue_ids) { if (input_queue_ids.empty() && output_queue_ids.empty()) { - GELOGE(GE_EXEC_MODEL_QUEUE_ID_INVALID, "Param is empty"); - return GE_EXEC_MODEL_QUEUE_ID_INVALID; + GELOGE(ACL_ERROR_GE_EXEC_MODEL_QUEUE_ID_INVALID, "Param is empty"); + return ACL_ERROR_GE_EXEC_MODEL_QUEUE_ID_INVALID; } input_queue_ids_ = input_queue_ids; @@ -1524,15 +1524,15 @@ Status DavinciModel::LoadWithQueue() { } if (input_queue_ids_.size() != new_input_data_info_.size()) { - GELOGE(GE_EXEC_MODEL_QUEUE_ID_INVALID, "Input queue ids not match model: input_queue=%zu input_data=%zu", + GELOGE(ACL_ERROR_GE_EXEC_MODEL_QUEUE_ID_INVALID, "Input queue ids not match model: input_queue=%zu input_data=%zu", input_queue_ids_.size(), new_input_data_info_.size()); - return GE_EXEC_MODEL_QUEUE_ID_INVALID; + return ACL_ERROR_GE_EXEC_MODEL_QUEUE_ID_INVALID; } if (output_queue_ids_.size() != new_output_data_info_.size()) { - GELOGE(GE_EXEC_MODEL_QUEUE_ID_INVALID, "Output queue ids not match model: output_queue=%zu output_data=%zu", + GELOGE(ACL_ERROR_GE_EXEC_MODEL_QUEUE_ID_INVALID, "Output queue ids not match model: output_queue=%zu output_data=%zu", output_queue_ids_.size(), new_output_data_info_.size()); - return GE_EXEC_MODEL_QUEUE_ID_INVALID; + return ACL_ERROR_GE_EXEC_MODEL_QUEUE_ID_INVALID; } GE_CHK_STATUS_RET(AddHeadStream(), "Add head stream failed."); @@ -1875,7 +1875,7 @@ Status DavinciModel::GetAIPPInfo(uint32_t index, AippConfigInfo &aipp_info) { OpDescPtr data_op = data_op_list_[index]; if (!data_op->HasAttr(ATTR_NAME_AIPP)) { GELOGW("GetAIPPInfo: there is not AIPP related with index %u.", index); - return GE_AIPP_NOT_EXIST; + return ACL_ERROR_GE_AIPP_NOT_EXIST; } std::unique_ptr aipp_params(new (std::nothrow) domi::AippOpParams()); @@ -1914,8 +1914,9 @@ Status DavinciModel::GetAippType(uint32_t index, InputAippType &type, size_t &ai } else if (data_mode == "dynamic_aipp_conf") { type = DYNAMIC_AIPP_NODE; } else { - GELOGE(INTERNAL_ERROR, "The info of aipp releated info %s is invalid with index %u.", data_mode.c_str(), index); - return INTERNAL_ERROR; + GELOGE(ACL_ERROR_GE_AIPP_MODE_INVALID, + "The info of aipp releated info %s is invalid with index %u.", data_mode.c_str(), index); + return ACL_ERROR_GE_AIPP_MODE_INVALID; } if (type == DATA_WITH_DYNAMIC_AIPP) { @@ -1929,8 +1930,8 @@ Status DavinciModel::GetAippType(uint32_t index, InputAippType &type, size_t &ai } } if (aipp_index == 0xFFFFFFFF) { - GELOGE(INTERNAL_ERROR, "Can not find aipp data node from index %u", index); - return INTERNAL_ERROR; + GELOGE(ACL_ERROR_GE_AIPP_NOT_EXIST, "Can not find aipp data node from index %u", index); + return ACL_ERROR_GE_AIPP_NOT_EXIST; } } return SUCCESS; @@ -4107,8 +4108,8 @@ Status DavinciModel::GetOrigInputInfo(uint32_t index, OriginInputInfo &orig_inpu GE_CHK_BOOL_RET_STATUS(index < data_op_list_.size(), PARAM_INVALID, "Index %u is invalid.", index); OpDescPtr data_op = data_op_list_[index]; if (!data_op->HasAttr(ATTR_NAME_AIPP_INPUTS) || !data_op->HasAttr(ATTR_NAME_AIPP_OUTPUTS)) { - GELOGE(GE_AIPP_NOT_EXIST, "GetOrigInputInfo: there is not AIPP related with index %u.", index); - return GE_AIPP_NOT_EXIST; + GELOGE(ACL_ERROR_GE_AIPP_NOT_EXIST, "GetOrigInputInfo: there is not AIPP related with index %u.", index); + return ACL_ERROR_GE_AIPP_NOT_EXIST; } vector inputs; @@ -4151,8 +4152,8 @@ Status DavinciModel::GetAllAippInputOutputDims(uint32_t index, std::vectorHasAttr(ATTR_NAME_AIPP_INPUTS) || !data_op->HasAttr(ATTR_NAME_AIPP_OUTPUTS)) { - GELOGE(GE_AIPP_NOT_EXIST, "GetAllAippInputOutputDims: there is not AIPP related with index %u.", index); - return GE_AIPP_NOT_EXIST; + GELOGE(ACL_ERROR_GE_AIPP_NOT_EXIST, "GetAllAippInputOutputDims: there is not AIPP related with index %u.", index); + return ACL_ERROR_GE_AIPP_NOT_EXIST; } vector inputs; diff --git a/ge/graph/load/new_model_manager/model_manager.cc b/ge/graph/load/new_model_manager/model_manager.cc index f5ed14d7..e51a205d 100755 --- a/ge/graph/load/new_model_manager/model_manager.cc +++ b/ge/graph/load/new_model_manager/model_manager.cc @@ -927,7 +927,7 @@ Status ModelManager::GetInputOutputDescInfo(const uint32_t model_id, vector> &batch_info, int32_t &dynamic_type) { std::shared_ptr davinci_model = GetModel(model_id); - GE_CHK_BOOL_RET_STATUS(davinci_model != nullptr, GE_EXEC_MODEL_ID_INVALID, + GE_CHK_BOOL_RET_STATUS(davinci_model != nullptr, ACL_ERROR_GE_EXEC_MODEL_ID_INVALID, "GetDynamicBatchInfo failed, Invalid model id %u!", model_id); return davinci_model->GetDynamicBatchInfo(batch_info, dynamic_type); @@ -942,8 +942,8 @@ Status ModelManager::GetDynamicBatchInfo(const uint32_t model_id, std::vector> &batch_info) { std::shared_ptr davinci_model = GetModel(model_id); - GE_CHK_BOOL_RET_STATUS(davinci_model != nullptr, PARAM_INVALID, "GetCombinedDynamicDims Failed, Invalid Model ID %u!", - model_id); + GE_CHK_BOOL_RET_STATUS(davinci_model != nullptr, ACL_ERROR_GE_EXEC_MODEL_ID_INVALID, + "GetCombinedDynamicDims Failed, Invalid Model ID %u!", model_id); davinci_model->GetCombinedDynamicDims(batch_info); return SUCCESS; @@ -959,7 +959,7 @@ Status ModelManager::GetCombinedDynamicDims(const uint32_t model_id, vector &user_input_shape_order) { auto davinci_model = GetModel(model_id); - GE_CHK_BOOL_RET_STATUS(davinci_model != nullptr, PARAM_INVALID, + GE_CHK_BOOL_RET_STATUS(davinci_model != nullptr, ACL_ERROR_GE_EXEC_MODEL_ID_INVALID, "GetUserDesignateShapeOrder Failed, Invalid Model ID %u!", model_id) davinci_model->GetUserDesignateShapeOrder(user_input_shape_order); return SUCCESS; @@ -1000,7 +1000,8 @@ Status ModelManager::GetInputOutputDescInfoForZeroCopy(const uint32_t model_id, /// Status ModelManager::GetAIPPInfo(const uint32_t model_id, uint32_t index, AippConfigInfo &aipp_info) { std::shared_ptr davinci_model = GetModel(model_id); - GE_CHK_BOOL_RET_STATUS(davinci_model != nullptr, PARAM_INVALID, "GetAIPPInfo failed, invalid model_id is %u.", + GE_CHK_BOOL_RET_STATUS(davinci_model != nullptr, ACL_ERROR_GE_EXEC_MODEL_ID_INVALID, + "GetAIPPInfo failed, invalid model_id is %u.", model_id); return davinci_model->GetAIPPInfo(index, aipp_info); @@ -1008,7 +1009,8 @@ Status ModelManager::GetAIPPInfo(const uint32_t model_id, uint32_t index, AippCo Status ModelManager::GetAippType(uint32_t model_id, uint32_t index, InputAippType &type, size_t &aipp_index) { std::shared_ptr davinci_model = GetModel(model_id); - GE_CHK_BOOL_RET_STATUS(davinci_model != nullptr, PARAM_INVALID, "GetAIPPInfo failed, invalid model_id is %u.", + GE_CHK_BOOL_RET_STATUS(davinci_model != nullptr, ACL_ERROR_GE_EXEC_MODEL_ID_INVALID, + "GetAIPPInfo failed, invalid model_id is %u.", model_id); return davinci_model->GetAippType(index, type, aipp_index); @@ -1035,7 +1037,8 @@ Status ModelManager::GenSessionId(uint64_t &session_id) { Status ModelManager::LoadModelOffline(uint32_t &model_id, const ModelData &model, shared_ptr listener, void *dev_ptr, size_t mem_size, void *weight_ptr, size_t weight_size) { - GE_CHK_BOOL_RET_STATUS(model.key.empty() || access(model.key.c_str(), F_OK) == 0, GE_EXEC_MODEL_KEY_PATH_INVALID, + GE_CHK_BOOL_RET_STATUS(model.key.empty() || access(model.key.c_str(), F_OK) == 0, + ACL_ERROR_GE_EXEC_MODEL_KEY_PATH_INVALID, "input key file path %s is invalid, %s", model.key.c_str(), strerror(errno)); GenModelId(&model_id); @@ -1054,8 +1057,8 @@ Status ModelManager::LoadModelOffline(uint32_t &model_id, const ModelData &model try { davinci_model = std::make_shared(model.priority, listener); } catch (std::bad_alloc &) { - GELOGE(MEMALLOC_FAILED, "Make shared failed"); - return MEMALLOC_FAILED; + GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "Make shared failed"); + return ACL_ERROR_GE_MEMORY_ALLOCATION; } catch (...) { GELOGE(INTERNAL_ERROR, "Make shared failed since other exception raise"); return INTERNAL_ERROR; @@ -1094,7 +1097,6 @@ Status ModelManager::LoadModelOffline(uint32_t &model_id, const ModelData &model GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(ret != SUCCESS, break, "DavinciInit failed."); InsertModel(model_id, davinci_model); - GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(davinci_model == nullptr, ret = PARAM_INVALID; break, "Insert model failed"); GELOGI("Parse model %u success.", model_id); @@ -1122,7 +1124,7 @@ Status ModelManager::LoadModelWithQ(uint32_t &model_id, const ModelData &model_d const std::vector &input_queue_ids, const std::vector &output_queue_ids) { GE_CHK_BOOL_RET_STATUS(model_data.key.empty() || access(model_data.key.c_str(), F_OK) == 0, - GE_EXEC_MODEL_KEY_PATH_INVALID, "input key file path %s is not valid, %s", + ACL_ERROR_GE_EXEC_MODEL_KEY_PATH_INVALID, "input key file path %s is not valid, %s", model_data.key.c_str(), strerror(errno)); ModelHelper model_helper; @@ -1134,8 +1136,8 @@ Status ModelManager::LoadModelWithQ(uint32_t &model_id, const ModelData &model_d shared_ptr davinci_model = MakeShared(model_data.priority, nullptr); if (davinci_model == nullptr) { - GELOGE(MEMALLOC_FAILED, "create model failed."); - return MEMALLOC_FAILED; + GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "create model failed."); + return ACL_ERROR_GE_MEMORY_ALLOCATION; } ret = davinci_model->Assign(model_helper.GetGeModel()); @@ -1390,13 +1392,13 @@ Status ModelManager::GetModelMemAndWeightSize(const ModelData &model, size_t &me auto partition_table = reinterpret_cast(model_data); if (partition_table->num == 1) { - GELOGE(GE_EXEC_MODEL_PARTITION_NUM_INVALID, "om model is error,please use executable om model"); - return GE_EXEC_MODEL_PARTITION_NUM_INVALID; + GELOGE(ACL_ERROR_GE_EXEC_MODEL_PARTITION_NUM_INVALID, "om model is error,please use executable om model"); + return ACL_ERROR_GE_EXEC_MODEL_PARTITION_NUM_INVALID; } ModelPartition task_partition; if (om_file_helper.GetModelPartition(ModelPartitionType::TASK_INFO, task_partition) != SUCCESS) { - GELOGE(GE_EXEC_LOAD_TASK_PARTITION_FAILED, "get task model partition failed."); - return GE_EXEC_LOAD_TASK_PARTITION_FAILED; + GELOGE(ACL_ERROR_GE_EXEC_LOAD_TASK_PARTITION_FAILED, "get task model partition failed."); + return ACL_ERROR_GE_EXEC_LOAD_TASK_PARTITION_FAILED; } std::shared_ptr model_task_def = MakeShared(); @@ -1405,14 +1407,14 @@ Status ModelManager::GetModelMemAndWeightSize(const ModelData &model, size_t &me } if (task_partition.size != 0) { if (!ReadProtoFromArray(task_partition.data, static_cast(task_partition.size), model_task_def.get())) { - GELOGE(GE_EXEC_LOAD_TASK_PARTITION_FAILED, "ReadProtoFromArray failed."); - return GE_EXEC_LOAD_TASK_PARTITION_FAILED; + GELOGE(ACL_ERROR_GE_EXEC_LOAD_TASK_PARTITION_FAILED, "ReadProtoFromArray failed."); + return ACL_ERROR_GE_EXEC_LOAD_TASK_PARTITION_FAILED; } } ModelPartition partition_weight; ret = om_file_helper.GetModelPartition(ModelPartitionType::WEIGHTS_DATA, partition_weight); - GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(ret != SUCCESS, return GE_EXEC_LOAD_WEIGHT_PARTITION_FAILED, + GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(ret != SUCCESS, return ACL_ERROR_GE_EXEC_LOAD_WEIGHT_PARTITION_FAILED, "Get weight partition failed. ret = %u", ret); mem_size = model_task_def->memory_size(); @@ -1431,7 +1433,8 @@ void ModelManager::GenModelId(uint32_t *id) { Status ModelManager::GetOrigInputInfo(uint32_t model_id, uint32_t index, OriginInputInfo &orig_input_info) { std::shared_ptr davinci_model = GetModel(model_id); - GE_CHK_BOOL_RET_STATUS(davinci_model != nullptr, PARAM_INVALID, "GetOrigInputInfo failed, invalid model_id is %u.", + GE_CHK_BOOL_RET_STATUS(davinci_model != nullptr, ACL_ERROR_GE_EXEC_MODEL_ID_INVALID, + "GetOrigInputInfo failed, invalid model_id is %u.", model_id); return davinci_model->GetOrigInputInfo(index, orig_input_info); @@ -1441,7 +1444,7 @@ Status ModelManager::GetAllAippInputOutputDims(uint32_t model_id, uint32_t index std::vector &input_dims, std::vector &output_dims) { std::shared_ptr davinci_model = GetModel(model_id); - GE_CHK_BOOL_RET_STATUS(davinci_model != nullptr, PARAM_INVALID, + GE_CHK_BOOL_RET_STATUS(davinci_model != nullptr, ACL_ERROR_GE_EXEC_MODEL_ID_INVALID, "GetAllAippInputOutputDims failed, invalid model_id is %u.", model_id); return davinci_model->GetAllAippInputOutputDims(index, input_dims, output_dims); diff --git a/ge/single_op/single_op.cc b/ge/single_op/single_op.cc index d7e67bc1..73b4c243 100755 --- a/ge/single_op/single_op.cc +++ b/ge/single_op/single_op.cc @@ -51,9 +51,9 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY SingleOp::~SingleOp() { Status SingleOp::ValidateArgs(const std::vector &inputs, const std::vector &outputs) { auto num_inputs = inputs.size(); if (num_inputs != input_sizes_.size()) { - GELOGE(PARAM_INVALID, "Input num mismatch. model expect %zu, but given %zu", input_addr_list_.size(), + GELOGE(ACL_ERROR_GE_PARAM_INVALID, "Input num mismatch. model expect %zu, but given %zu", input_addr_list_.size(), inputs.size()); - return PARAM_INVALID; + return ACL_ERROR_GE_PARAM_INVALID; } for (size_t i = 0; i < num_inputs; ++i) { @@ -62,16 +62,16 @@ Status SingleOp::ValidateArgs(const std::vector &inputs, const std:: GELOGI("Input [%zu], aligned_size:%zu, inputs.length:%lu, input_sizes_:%lu", i, aligned_size, inputs[i].length, input_sizes_[i]); if (aligned_size < input_sizes_[i]) { - GELOGE(PARAM_INVALID, "Input size mismatch. index = %zu, model expect %zu," + GELOGE(ACL_ERROR_GE_PARAM_INVALID, "Input size mismatch. index = %zu, model expect %zu," " but given %zu(after align)", i, input_sizes_[i], aligned_size); - return PARAM_INVALID; + return ACL_ERROR_GE_PARAM_INVALID; } } auto num_outputs = outputs.size(); if (num_outputs != output_sizes_.size()) { - GELOGE(PARAM_INVALID, "output num mismatch. model expect %zu, but given %zu", output_sizes_.size(), outputs.size()); - return PARAM_INVALID; + GELOGE(ACL_ERROR_GE_PARAM_INVALID, "output num mismatch. model expect %zu, but given %zu", output_sizes_.size(), outputs.size()); + return ACL_ERROR_GE_PARAM_INVALID; } for (size_t i = 0; i < num_outputs; ++i) { @@ -80,9 +80,9 @@ Status SingleOp::ValidateArgs(const std::vector &inputs, const std:: GELOGI("Output [%zu], aligned_size:%zu, outputs.length:%lu, output_sizes_:%lu", i, aligned_size, outputs[i].length, output_sizes_[i]); if (aligned_size < output_sizes_[i]) { - GELOGE(PARAM_INVALID, "Output size mismatch. index = %zu, model expect %zu," + GELOGE(ACL_ERROR_GE_PARAM_INVALID, "Output size mismatch. index = %zu, model expect %zu," "but given %zu(after align)", i, output_sizes_[i], aligned_size); - return PARAM_INVALID; + return ACL_ERROR_GE_PARAM_INVALID; } } @@ -134,8 +134,8 @@ Status SingleOp::UpdateArgs(const std::vector &inputs, const std::ve RT_MEMCPY_HOST_TO_DEVICE_EX, stream_); if (rt_ret != RT_ERROR_NONE) { - GELOGE(RT_FAILED, "rtMemcpyAsync addresses failed, ret = %d", rt_ret); - return RT_FAILED; + GELOGE(rt_ret, "rtMemcpyAsync addresses failed, ret = %d", rt_ret); + return rt_ret; } } else if (task->GetOpTaskType() == OP_TASK_AICPUCC) { GELOGD("Update aicpu_CC task args"); @@ -198,29 +198,29 @@ Status DynamicSingleOp::ValidateParams(const vector &input_desc, std::vector &output_desc, std::vector &outputs) const { if (inputs.size() != input_desc.size()) { - GELOGE(PARAM_INVALID, + GELOGE(ACL_ERROR_GE_PARAM_INVALID, "Input number mismatches input desc number. Input num = %zu, input desc num = %zu", inputs.size(), input_desc.size()); - return PARAM_INVALID; + return ACL_ERROR_GE_PARAM_INVALID; } if (outputs.size() != output_desc.size()) { - GELOGE(PARAM_INVALID, + GELOGE(ACL_ERROR_GE_PARAM_INVALID, "Output number mismatches output desc number. Output num = %zu, output desc num = %zu", outputs.size(), output_desc.size()); - return PARAM_INVALID; + return ACL_ERROR_GE_PARAM_INVALID; } if (input_desc.size() != num_inputs_) { - GELOGE(PARAM_INVALID, "Input number mismatches. expect %zu, but given %zu", num_inputs_, input_desc.size()); - return PARAM_INVALID; + GELOGE(ACL_ERROR_GE_PARAM_INVALID, "Input number mismatches. expect %zu, but given %zu", num_inputs_, input_desc.size()); + return ACL_ERROR_GE_PARAM_INVALID; } if (output_desc.size() != num_outputs_) { - GELOGE(PARAM_INVALID, "Output number mismatches. expect %zu, but given %zu", num_outputs_, output_desc.size()); - return PARAM_INVALID; + GELOGE(ACL_ERROR_GE_PARAM_INVALID, "Output number mismatches. expect %zu, but given %zu", num_outputs_, output_desc.size()); + return ACL_ERROR_GE_PARAM_INVALID; } return SUCCESS; @@ -247,8 +247,8 @@ Status DynamicSingleOp::AllocateWorkspaces(const std::vector &workspace GE_CHECK_NOTNULL(stream_resource); auto ws_base = stream_resource->MallocMemory(kPurpose, static_cast(total_size)); if (ws_base == nullptr) { - GELOGE(MEMALLOC_FAILED, "Failed to allocate memory of size: %ld", total_size); - return MEMALLOC_FAILED; + GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "Failed to allocate memory of size: %ld", total_size); + return ACL_ERROR_GE_MEMORY_ALLOCATION; } GELOGD("Done allocating workspace memory successfully."); @@ -293,10 +293,10 @@ Status DynamicSingleOp::ExecuteAsync(const vector &input_desc, } else if (op_task_->GetOpTaskType() == OP_TASK_AICPU || op_task_->GetOpTaskType() == OP_TASK_AICPUCC) { return op_task_->LaunchKernel(input_desc, input_buffers, output_desc, output_buffers, stream_); } else { - GELOGE(UNSUPPORTED, + GELOGE(ACL_ERROR_GE_OP_TASK_TYPE_INVALID, "Only TBE_Task, AI_CPU_Task and AI_CPUCC_Task are supported, but got %u", op_task_->GetOpTaskType()); - return UNSUPPORTED; + return ACL_ERROR_GE_OP_TASK_TYPE_INVALID; } } diff --git a/ge/single_op/single_op_manager.cc b/ge/single_op/single_op_manager.cc index 56bbdef6..d523d355 100644 --- a/ge/single_op/single_op_manager.cc +++ b/ge/single_op/single_op_manager.cc @@ -33,16 +33,16 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status SingleOpManager::GetOpFr SingleOp **single_op) { GELOGI("GetOpFromModel in. model name = %s", model_name.c_str()); if (single_op == nullptr) { - GELOGE(PARAM_INVALID, "single op is null"); - return PARAM_INVALID; + GELOGE(ACL_ERROR_GE_INTERNAL_ERROR, "single op is null"); + return ACL_ERROR_GE_INTERNAL_ERROR; } uintptr_t resource_id = 0; GE_CHK_STATUS_RET(GetResourceId(stream, resource_id)); StreamResource *res = GetResource(resource_id, stream); if (res == nullptr) { - GELOGE(MEMALLOC_FAILED, "GetResource failed"); - return MEMALLOC_FAILED; + GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "GetResource failed"); + return ACL_ERROR_GE_MEMORY_ALLOCATION; } SingleOp *op = res->GetOperator(model_data.model_data); @@ -109,8 +109,8 @@ Status SingleOpManager::GetDynamicOpFromModel(const string &model_name, GE_CHK_STATUS_RET(GetResourceId(stream, resource_id)); StreamResource *res = GetResource(resource_id, stream); if (res == nullptr) { - GELOGE(MEMALLOC_FAILED, "GetResource failed"); - return MEMALLOC_FAILED; + GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "GetResource failed"); + return ACL_ERROR_GE_MEMORY_ALLOCATION; } DynamicSingleOp *op = res->GetDynamicOperator(model_data.model_data); @@ -140,8 +140,8 @@ Status SingleOpManager::GetResourceId(rtStream_t stream, uintptr_t &resource_id) rtContext_t rt_cur_ctx = nullptr; auto rt_err = rtCtxGetCurrent(&rt_cur_ctx); if (rt_err != RT_ERROR_NONE) { - GELOGE(RT_FAILED, "get current context failed, runtime result is %d", static_cast(rt_err)); - return RT_FAILED; + GELOGE(rt_err, "get current context failed, runtime result is %d", static_cast(rt_err)); + return rt_err; } // use current context as resource key instead GELOGI("use context as resource key instead when default stream"); diff --git a/ge/single_op/single_op_model.cc b/ge/single_op/single_op_model.cc index ea9df11d..65eb58be 100755 --- a/ge/single_op/single_op_model.cc +++ b/ge/single_op/single_op_model.cc @@ -94,7 +94,7 @@ Status SingleOpModel::InitModelMem(StreamResource &res) { GELOGI("total memory: %lu, zero_copy_mem: %lu", model_params_.memory_size, model_params_.zero_copy_mem_size); model_params_.mem_base = res.MallocMemory(purpose, model_params_.memory_size - model_params_.zero_copy_mem_size); if (model_params_.mem_base == nullptr) { - return RT_FAILED; + return ACL_ERROR_GE_MEMORY_ALLOCATION; } } @@ -103,7 +103,7 @@ Status SingleOpModel::InitModelMem(StreamResource &res) { model_params_.weight_base = res.MallocWeight(purpose, model_params_.weight_size); if (model_params_.weight_base == nullptr) { // no need to free memory, for that was handled by StreamResources - return RT_FAILED; + return ACL_ERROR_GE_MEMORY_ALLOCATION; } auto weight_buffer = model_helper_.GetGeModel()->GetWeight(); @@ -121,8 +121,9 @@ Status SingleOpModel::InitModelMem(StreamResource &res) { Status SingleOpModel::ParseInputNode(const OpDescPtr &op_desc) { vector offsets = op_desc->GetOutputOffset(); if (offsets.size() != kDataOutputNum) { - GELOGE(PARAM_INVALID, "Data op should have only one output, but got %zu", op_desc->GetOutputOffset().size()); - return PARAM_INVALID; + GELOGE(ACL_ERROR_GE_PARAM_INVALID, + "Data op should have only one output, but got %zu", op_desc->GetOutputOffset().size()); + return ACL_ERROR_GE_PARAM_INVALID; } auto output_desc = op_desc->GetOutputDescPtr(0); @@ -158,8 +159,8 @@ Status SingleOpModel::LoadAllNodes() { Graph graph = ge_model->GetGraph(); auto compute_graph = GraphUtils::GetComputeGraph(graph); if (compute_graph == nullptr) { - GELOGE(PARAM_INVALID, "[%s] compute_graph is null", model_name_.c_str()); - return PARAM_INVALID; + GELOGE(ACL_ERROR_GE_INTERNAL_ERROR, "[%s] compute_graph is null", model_name_.c_str()); + return ACL_ERROR_GE_INTERNAL_ERROR; } auto nodes = compute_graph->GetDirectNode(); @@ -257,8 +258,8 @@ Status SingleOpModel::BuildTaskList(SingleOp &single_op) { } single_op.tasks_.emplace_back(task); } else { - GELOGE(UNSUPPORTED, "Only TBE, AI_CPU, CUST_AI_CPU kernel are supported, but got %u", context.kernel_type()); - return UNSUPPORTED; + GELOGE(ACL_ERROR_GE_OP_KERNEL_TYPE_INVALID, "Only TBE, AI_CPU, CUST_AI_CPU kernel are supported, but got %u", context.kernel_type()); + return ACL_ERROR_GE_OP_KERNEL_TYPE_INVALID; } } else if (task_type == RT_MODEL_TASK_KERNEL_EX) { GELOGD("Building AICPU_TF task"); @@ -282,7 +283,7 @@ Status SingleOpModel::BuildTaskList(SingleOp &single_op) { void SingleOpModel::ParseArgTable(TbeOpTask *task, SingleOp &op) { if (task == nullptr) { - GELOGE(PARAM_INVALID, "tbe op task is nullptr"); + GELOGE(ACL_ERROR_GE_INTERNAL_ERROR, "tbe op task is nullptr"); return; } // args: addr1, addr2, addr3 ... @@ -305,14 +306,14 @@ Status SingleOpModel::BuildKernelTask(const domi::KernelDef &kernel_def, TbeOpTa const auto &context = kernel_def.context(); auto iter = op_list_.find(context.op_index()); if (iter == op_list_.end()) { - GELOGE(INTERNAL_ERROR, "op desc not found. op index = %u", context.op_index()); - return INTERNAL_ERROR; + GELOGE(ACL_ERROR_GE_INTERNAL_ERROR, "op desc not found. op index = %u", context.op_index()); + return ACL_ERROR_GE_INTERNAL_ERROR; } auto *tbe_task = new (std::nothrow) TbeOpTask(); if (tbe_task == nullptr) { - GELOGE(MEMALLOC_FAILED, "create tbe op task failed"); - return MEMALLOC_FAILED; + GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "create tbe op task failed"); + return ACL_ERROR_GE_MEMORY_ALLOCATION; } auto builder = TbeTaskBuilder(model_name_, iter->second, kernel_def); @@ -331,14 +332,14 @@ Status SingleOpModel::BuildKernelExTask(const domi::KernelExDef &kernel_def, AiC bool dynamic_flag, bool& depend_compute_flag, uint64_t session_id) { auto iter = op_list_.find(kernel_def.op_index()); if (iter == op_list_.end()) { - GELOGE(INTERNAL_ERROR, "op desc not found. op index = %u", kernel_def.op_index()); - return INTERNAL_ERROR; + GELOGE(ACL_ERROR_GE_INTERNAL_ERROR, "op desc not found. op index = %u", kernel_def.op_index()); + return ACL_ERROR_GE_INTERNAL_ERROR; } std::unique_ptr aicpu_task(new (std::nothrow) AiCpuTask()); if (aicpu_task == nullptr) { - GELOGE(MEMALLOC_FAILED, "create aicpu_TF op task failed"); - return MEMALLOC_FAILED; + GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "create aicpu_TF op task failed"); + return ACL_ERROR_GE_MEMORY_ALLOCATION; } auto builder = AiCpuTaskBuilder(iter->second->GetOpDesc(), kernel_def); auto ret = builder.BuildTask(*aicpu_task, model_params_, dynamic_flag, session_id); @@ -356,13 +357,13 @@ Status SingleOpModel::BuildCpuKernelTask(const domi::KernelDef &kernel_def, OpTa const auto &context = kernel_def.context(); auto iter = op_list_.find(context.op_index()); if (iter == op_list_.end()) { - GELOGE(INTERNAL_ERROR, "op desc not found. op index = %u", context.op_index()); - return INTERNAL_ERROR; + GELOGE(ACL_ERROR_GE_INTERNAL_ERROR, "op desc not found. op index = %u", context.op_index()); + return ACL_ERROR_GE_INTERNAL_ERROR; } std::unique_ptr aicpucc_task(new (std::nothrow) AiCpuCCTask()); if (aicpucc_task == nullptr) { - GELOGE(MEMALLOC_FAILED, "create aicpu_CC op task failed"); - return MEMALLOC_FAILED; + GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "create aicpu_CC op task failed"); + return ACL_ERROR_GE_MEMORY_ALLOCATION; } auto builder = AiCpuCCTaskBuilder(iter->second->GetOpDesc(), kernel_def); @@ -398,8 +399,9 @@ Status SingleOpModel::BuildModelTaskKernel(const TaskDef &task_def, DynamicSingl GE_CHK_STATUS_RET_NOLOG(BuildCpuKernelTask(task_def.kernel(), &task)); single_op.op_task_.reset(task); } else { - GELOGE(UNSUPPORTED, "Only TBE, AI_CPU, CUST_AI_CPU kernel are supported, but got %u", context.kernel_type()); - return UNSUPPORTED; + GELOGE(ACL_ERROR_GE_OP_KERNEL_TYPE_INVALID, + "Only TBE, AI_CPU, CUST_AI_CPU kernel are supported, but got %u", context.kernel_type()); + return ACL_ERROR_GE_OP_KERNEL_TYPE_INVALID; } return SUCCESS; } @@ -422,8 +424,8 @@ Status SingleOpModel::BuildTaskListForDynamicOp(DynamicSingleOp &single_op) { GE_CHK_STATUS_RET_NOLOG(BuildModelTaskKernel(task_def, single_op)); } else if (task_type == RT_MODEL_TASK_KERNEL_EX) { if (single_op.op_task_ != nullptr) { - GELOGE(UNSUPPORTED, "Do not support dynamic op with multiple tasks."); - return UNSUPPORTED; + GELOGE(ACL_ERROR_GE_OP_TASK_TYPE_INVALID, "Do not support dynamic op with multiple tasks."); + return ACL_ERROR_GE_OP_TASK_TYPE_INVALID; } GELOGD("Building AICPU_TF task"); AiCpuTask *aicpu_task = nullptr; @@ -434,8 +436,8 @@ Status SingleOpModel::BuildTaskListForDynamicOp(DynamicSingleOp &single_op) { depend_compute_flag, dynamic_singleop_sessionid)); if (depend_compute_flag) { if (i >= tasks.size() - 1) { - GELOGE(FAILED, "The copy task of the fourth operator was not found."); - return FAILED; + GELOGE(ACL_ERROR_GE_PARAM_INVALID, "The copy task of the fourth operator was not found."); + return ACL_ERROR_GE_PARAM_INVALID; } ++i; const TaskDef ©_task_def = tasks[i]; diff --git a/ge/single_op/stream_resource.cc b/ge/single_op/stream_resource.cc index 388f447e..f545b6c8 100755 --- a/ge/single_op/stream_resource.cc +++ b/ge/single_op/stream_resource.cc @@ -160,8 +160,8 @@ Status StreamResource::BuildOperator(const string &model_name, const ModelData & auto new_op = std::unique_ptr(new(std::nothrow) SingleOp(&stream_mu_, stream_)); if (new_op == nullptr) { - GELOGE(MEMALLOC_FAILED, "new SingleOp failed"); - return MEMALLOC_FAILED; + GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "new SingleOp failed"); + return ACL_ERROR_GE_MEMORY_ALLOCATION; } GELOGI("To build operator: %s", model_name.c_str()); diff --git a/ge/single_op/task/aicpu_kernel_task_builder.cc b/ge/single_op/task/aicpu_kernel_task_builder.cc index 150c66e7..8e140a6f 100755 --- a/ge/single_op/task/aicpu_kernel_task_builder.cc +++ b/ge/single_op/task/aicpu_kernel_task_builder.cc @@ -25,20 +25,20 @@ AiCpuCCTaskBuilder::AiCpuCCTaskBuilder(const OpDescPtr &op_desc, const domi::Ker Status AiCpuCCTaskBuilder::SetKernelArgs(AiCpuCCTask &task) { size_t aicpu_arg_size = kernel_def_.args_size(); if (aicpu_arg_size <= 0) { - GELOGE(RT_FAILED, "aicpu_arg_size is invalid, value = %zu", aicpu_arg_size); - return RT_FAILED; + GELOGE(ACL_ERROR_GE_PARAM_INVALID, "aicpu_arg_size is invalid, value = %zu", aicpu_arg_size); + return ACL_ERROR_GE_PARAM_INVALID; } std::unique_ptr aicpu_args; aicpu_args.reset(new(std::nothrow) uint8_t[aicpu_arg_size]()); if (aicpu_args == nullptr) { - GELOGE(RT_FAILED, "malloc failed, size = %zu", aicpu_arg_size); - return RT_FAILED; + GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "malloc failed, size = %zu", aicpu_arg_size); + return ACL_ERROR_GE_MEMORY_ALLOCATION; } auto err = memcpy_s(aicpu_args.get(), aicpu_arg_size, kernel_def_.args().data(), aicpu_arg_size); if (err != EOK) { - GELOGE(RT_FAILED, "memcpy_s args failed, size = %zu, err = %d", aicpu_arg_size, err); - return RT_FAILED; + GELOGE(ACL_ERROR_GE_INTERNAL_ERROR, "memcpy_s args failed, size = %zu, err = %d", aicpu_arg_size, err); + return ACL_ERROR_GE_INTERNAL_ERROR; } task.SetIoAddr(aicpu_args.get() + sizeof(aicpu::AicpuParamHead)); diff --git a/ge/single_op/task/aicpu_task_builder.cc b/ge/single_op/task/aicpu_task_builder.cc index 3adfcd11..468fee86 100755 --- a/ge/single_op/task/aicpu_task_builder.cc +++ b/ge/single_op/task/aicpu_task_builder.cc @@ -30,8 +30,8 @@ namespace ge { size_t arg_size = kernel_def_.args_size(); auto rt_ret = rtMalloc(io_addr, arg_size, RT_MEMORY_HBM); if (rt_ret != RT_ERROR_NONE) { - GELOGE(RT_FAILED, "rtMalloc failed, size = %zu, ret = %d", arg_size, rt_ret); - return RT_FAILED; + GELOGE(rt_ret, "rtMalloc failed, size = %zu, ret = %d", arg_size, rt_ret); + return rt_ret; } const void *src_addr = reinterpret_cast(addresses.data()); @@ -39,8 +39,8 @@ namespace ge { rt_ret = rtMemcpy(*io_addr, arg_size, src_addr, src_len, RT_MEMCPY_HOST_TO_DEVICE); if (rt_ret != RT_ERROR_NONE) { (void)rtFree(*io_addr); - GELOGE(RT_FAILED, "rtMemcpy addresses failed, ret = %d", rt_ret); - return RT_FAILED; + GELOGE(rt_ret, "rtMemcpy addresses failed, ret = %d", rt_ret); + return rt_ret; } return SUCCESS; @@ -50,8 +50,8 @@ namespace ge { auto sec_ret = memcpy_s(&fwk_op_kernel, sizeof(STR_FWK_OP_KERNEL), kernel_def_.args().data(), kernel_def_.args().size()); if (sec_ret != EOK) { - GELOGE(FAILED, "memcpy failed, ret: %d", sec_ret); - return FAILED; + GELOGE(ACL_ERROR_GE_INTERNAL_ERROR, "memcpy failed, ret: %d", sec_ret); + return ACL_ERROR_GE_INTERNAL_ERROR; } auto io_addr_val = static_cast(reinterpret_cast(io_addr)); @@ -65,16 +65,16 @@ namespace ge { void *fwk_op_args = nullptr; auto rt_ret = rtMalloc(&fwk_op_args, sizeof(STR_FWK_OP_KERNEL), RT_MEMORY_HBM); if (rt_ret != RT_ERROR_NONE) { - GELOGE(RT_FAILED, "malloc arg memory failed, ret = %d", rt_ret); - return RT_FAILED; + GELOGE(rt_ret, "malloc arg memory failed, ret = %d", rt_ret); + return rt_ret; } rt_ret = rtMemcpy(fwk_op_args, sizeof(STR_FWK_OP_KERNEL), &fwk_op_kernel, sizeof(STR_FWK_OP_KERNEL), RT_MEMCPY_HOST_TO_DEVICE); if (rt_ret != RT_ERROR_NONE) { (void)rtFree(fwk_op_args); - GELOGE(RT_FAILED, "copy args failed, ret = %d", rt_ret); - return RT_FAILED; + GELOGE(rt_ret, "copy args failed, ret = %d", rt_ret); + return rt_ret; } *args = fwk_op_args; return SUCCESS; @@ -83,9 +83,9 @@ namespace ge { Status AiCpuTaskBuilder::InitWorkspaceAndIO(void **io_addr, void **kernel_workspace, const SingleOpModelParam ¶m, bool dynamic_flag) { if (kernel_def_.args_size() > sizeof(STR_FWK_OP_KERNEL)) { - GELOGE(PARAM_INVALID, "sizeof STR_FWK_OP_KERNEL is: %lu, but args_size is: %d", + GELOGE(ACL_ERROR_GE_PARAM_INVALID, "sizeof STR_FWK_OP_KERNEL is: %lu, but args_size is: %d", sizeof(STR_FWK_OP_KERNEL), kernel_def_.args_size()); - return PARAM_INVALID; + return ACL_ERROR_GE_PARAM_INVALID; } auto addresses = BuildTaskUtils::GetAddresses(op_desc_, param); auto ws_addr_vec = addresses.at(BuildTaskUtils::kAddressIndexWorkspace); @@ -94,8 +94,8 @@ namespace ge { GE_CHK_RT_RET(rtMalloc(kernel_workspace, kernel_def_.task_info_size(), RT_MEMORY_HBM)); } else { if (ws_addr_vec.empty()) { - GELOGE(PARAM_INVALID, "workspace Data Address is empty."); - return PARAM_INVALID; + GELOGE(ACL_ERROR_GE_PARAM_INVALID, "workspace Data Address is empty."); + return ACL_ERROR_GE_PARAM_INVALID; } *kernel_workspace = ws_addr_vec[0]; } @@ -143,8 +143,8 @@ namespace ge { GELOGI("Begin to CreateAicpuSession, session id: %lu", session_id); GE_CHECK_NOTNULL(ModelManager::GetInstance()); GE_IF_BOOL_EXEC(ModelManager::GetInstance()->CreateAicpuSession(session_id) != SUCCESS, - GELOGE(FAILED, "CreateAicpuSession error. session id: %lu", session_id); - return FAILED;) + GELOGE(ACL_ERROR_GE_INTERNAL_ERROR, "CreateAicpuSession error. session id: %lu", session_id); + return ACL_ERROR_GE_INTERNAL_ERROR;) ret = SetKernelArgs(&task.args_, fwk_op_kernel); if (ret != SUCCESS) { return ret; diff --git a/ge/single_op/task/op_task.cc b/ge/single_op/task/op_task.cc index e76da6cf..30d4d311 100755 --- a/ge/single_op/task/op_task.cc +++ b/ge/single_op/task/op_task.cc @@ -693,8 +693,8 @@ Status AiCpuCCTask::LaunchKernel(rtStream_t stream) { block_dim_, args_.get(), static_cast(arg_size_), sm_desc, stream, dump_flag_); if (ret != RT_ERROR_NONE) { - GELOGE(RT_FAILED, "Invoke rtCpuKernelLaunch failed. ret = %d", ret); - return RT_FAILED; + GELOGE(ret, "Invoke rtCpuKernelLaunch failed. ret = %d", ret); + return ret; } GELOGD("Invoke rtCpuKernelLaunch succeeded"); diff --git a/ge/single_op/task/tbe_task_builder.cc b/ge/single_op/task/tbe_task_builder.cc index 935c62a3..e06a08c6 100644 --- a/ge/single_op/task/tbe_task_builder.cc +++ b/ge/single_op/task/tbe_task_builder.cc @@ -91,9 +91,9 @@ Status TbeTaskBuilder::DoRegisterBinary(const OpKernelBin &kernel_bin, void **bi binary.magic = param.core_type == 0 ? RT_DEV_BINARY_MAGIC_ELF : RT_DEV_BINARY_MAGIC_ELF_AIVEC; auto ret = rtDevBinaryRegister(&binary, bin_handle); if (ret != RT_ERROR_NONE) { - GELOGE(RT_FAILED, "rtDevBinaryRegister failed, bin key = %s, core_type = %ld, rt ret = %d", stub_name_.c_str(), + GELOGE(ret, "rtDevBinaryRegister failed, bin key = %s, core_type = %ld, rt ret = %d", stub_name_.c_str(), param.core_type, static_cast(ret)); - return RT_FAILED; + return ret; } return SUCCESS; @@ -106,9 +106,9 @@ Status TbeTaskBuilder::DoRegisterMeta(void *bin_handle) { if (!meta_data.empty()) { auto rt_ret = rtMetadataRegister(bin_handle, meta_data.c_str()); if (rt_ret != RT_ERROR_NONE) { - GELOGE(RT_FAILED, "rtMetadataRegister failed. bin key = %s, meta_data = %s, rt ret = %d", stub_name_.c_str(), + GELOGE(rt_ret, "rtMetadataRegister failed. bin key = %s, meta_data = %s, rt ret = %d", stub_name_.c_str(), meta_data.c_str(), static_cast(rt_ret)); - return RT_FAILED; + return rt_ret; } } @@ -118,9 +118,9 @@ Status TbeTaskBuilder::DoRegisterMeta(void *bin_handle) { Status TbeTaskBuilder::DoRegisterFunction(void *bin_handle, const char *stub_name, const char *kernel_name) { auto rt_ret = rtFunctionRegister(bin_handle, stub_name, stub_name, kernel_name, FUNC_MODE_NORMAL); if (rt_ret != RT_ERROR_NONE) { - GELOGE(RT_FAILED, "rtFunctionRegister failed. bin key = %s, kernel name = %s, rt ret = %d", stub_name, kernel_name, + GELOGE(rt_ret, "rtFunctionRegister failed. bin key = %s, kernel name = %s, rt ret = %d", stub_name, kernel_name, static_cast(rt_ret)); - return RT_FAILED; + return rt_ret; } return SUCCESS; @@ -173,14 +173,14 @@ Status TbeTaskBuilder::RegisterKernel(TbeOpTask &task, const SingleOpModelParam auto tbe_kernel = GetTbeKernel(op_desc_); if (tbe_kernel == nullptr) { - GELOGE(PARAM_INVALID, "OP EXT ATTR NAME TBE_KERNEL not found. op = %s", op_desc_->GetName().c_str()); - return PARAM_INVALID; + GELOGE(ACL_ERROR_GE_INTERNAL_ERROR, "OP EXT ATTR NAME TBE_KERNEL not found. op = %s", op_desc_->GetName().c_str()); + return ACL_ERROR_GE_INTERNAL_ERROR; } auto holder = std::unique_ptr(new (std::nothrow) KernelHolder(stub_func, tbe_kernel)); if (holder == nullptr) { - GELOGE(MEMALLOC_FAILED, "create KernelHodler failed."); - return MEMALLOC_FAILED; + GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "create KernelHodler failed."); + return ACL_ERROR_GE_MEMORY_ALLOCATION; } void *bin_handle = nullptr; @@ -189,8 +189,8 @@ Status TbeTaskBuilder::RegisterKernel(TbeOpTask &task, const SingleOpModelParam holder->SetBinHandle(bin_handle); if (!registry.AddKernel(stub_name_, std::move(holder))) { // should not happen. only one thread can reach here - GELOGE(INTERNAL_ERROR, "Add kernel failed. stub name = %s", stub_name_.c_str()); - return INTERNAL_ERROR; + GELOGE(ACL_ERROR_GE_INTERNAL_ERROR, "Add kernel failed. stub name = %s", stub_name_.c_str()); + return ACL_ERROR_GE_INTERNAL_ERROR; } } } @@ -218,15 +218,15 @@ Status TbeTaskBuilder::GetSmDesc(void **sm_desc, const SingleOpModelParam ¶m auto rtRet = rtMemAllocManaged(sm_desc, sm_desc_str.size(), RT_MEMORY_SPM); if (rtRet != RT_ERROR_NONE) { - GELOGE(RT_FAILED, "rtMemAllocManaged failed, ret: %d", static_cast(rtRet)); - return RT_FAILED; + GELOGE(rtRet, "rtMemAllocManaged failed, ret: %d", static_cast(rtRet)); + return rtRet; } rtRet = rtMemcpy(*sm_desc, sm_desc_str.size(), sm_desc_str.data(), sm_desc_str.size(), RT_MEMCPY_HOST_TO_DEVICE); if (rtRet != RT_ERROR_NONE) { (void)rtMemFreeManaged(*sm_desc); - GELOGE(RT_FAILED, "rtMemcpy, ret: %d", static_cast(rtRet)); - return RT_FAILED; + GELOGE(rtRet, "rtMemcpy, ret: %d", static_cast(rtRet)); + return rtRet; } } @@ -240,8 +240,8 @@ Status TbeTaskBuilder::SetKernelArgs(TbeOpTask &task, const SingleOpModelParam & auto rtRet = rtMemcpy(args.get(), arg_size, kernel_def_.args().data(), arg_size, RT_MEMCPY_HOST_TO_HOST); if (rtRet != RT_ERROR_NONE) { - GELOGE(RT_FAILED, "rtMemcpy args failed, size = %zu, ret = %d", arg_size, static_cast(rtRet)); - return RT_FAILED; + GELOGE(rtRet, "rtMemcpy args failed, size = %zu, ret = %d", arg_size, static_cast(rtRet)); + return rtRet; } const domi::KernelContext &context = kernel_def_.context(); @@ -259,8 +259,8 @@ Status TbeTaskBuilder::SetKernelArgs(TbeOpTask &task, const SingleOpModelParam & uint64_t src_len = sizeof(void *) * tensor_device_addr_vec.size(); rtRet = rtMemcpy(args.get() + offset, arg_size - offset, src_addr, src_len, RT_MEMCPY_HOST_TO_HOST); if (rtRet != RT_ERROR_NONE) { - GELOGE(RT_FAILED, "rtMemcpy addresses failed, ret = %d", static_cast(rtRet)); - return RT_FAILED; + GELOGE(rtRet, "rtMemcpy addresses failed, ret = %d", static_cast(rtRet)); + return rtRet; } } @@ -285,8 +285,8 @@ Status TbeTaskBuilder::BuildTask(TbeOpTask &task, const SingleOpModelParam ¶ void *stub_func = nullptr; auto rtRet = rtGetFunctionByName(stub_name_.c_str(), &stub_func); if (rtRet != SUCCESS) { - GELOGE(RT_FAILED, "rtGetFunctionByName failed."); - return RT_FAILED; + GELOGE(rtRet, "rtGetFunctionByName failed."); + return rtRet; } task.SetStubFunc(stub_name_, stub_func); @@ -299,8 +299,8 @@ Status TbeTaskBuilder::InitTilingInfo(TbeOpTask &task) { (void)AttrUtils::GetInt(op_desc_, kAttrOpParamSize, max_size); GELOGD("Got op param size by key: %s, ret = %ld", kAttrOpParamSize, max_size); if (max_size <= 0) { - GELOGE(PARAM_INVALID, "[%s] Invalid op_param_size: %ld.", op_desc_->GetName().c_str(), max_size); - return PARAM_INVALID; + GELOGE(ACL_ERROR_GE_PARAM_INVALID, "[%s] Invalid op_param_size: %ld.", op_desc_->GetName().c_str(), max_size); + return ACL_ERROR_GE_PARAM_INVALID; } void *tiling_buffer = nullptr; diff --git a/inc/external/ge/ge_api_error_codes.h b/inc/external/ge/ge_api_error_codes.h index 7b045d54..1a25b86d 100644 --- a/inc/external/ge/ge_api_error_codes.h +++ b/inc/external/ge/ge_api_error_codes.h @@ -19,6 +19,7 @@ #include #include +#include "ge_error_codes.h" namespace ge { class StatusFactory { @@ -66,11 +67,47 @@ class ErrorNoRegisterar { ((0xFF & (static_cast(modid))) << 12) | (0x0FFF & (static_cast(value))); \ const ErrorNoRegisterar g_##name##_errorno(name, desc); +#define GE_ERRORNO_EXTERNAL(name, desc) const ErrorNoRegisterar g_##name##_errorno(name, desc); + using Status = uint32_t; // General error code GE_ERRORNO(0, 0, 0, 0, 0, SUCCESS, 0, "success"); GE_ERRORNO(0b11, 0b11, 0b111, 0xFF, 0b11111, FAILED, 0xFFF, "failed"); /*lint !e401*/ + +GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_PARAM_INVALID, "Parameter invalid."); +GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_EXEC_NOT_INIT, "GE executor not initialized yet."); +GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_EXEC_MODEL_PATH_INVALID, "Model file path invalid."); +GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_EXEC_MODEL_ID_INVALID, "Model id invalid."); +GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_EXEC_MODEL_KEY_PATH_INVALID, "Model key path invalid."); +GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_EXEC_MODEL_NOT_SUPPORT_ENCRYPTION, "Model does not support encryption."); +GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_EXEC_MODEL_DATA_SIZE_INVALID, "Data size of model invalid."); +GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_EXEC_MODEL_ADDR_INVALID, "Model addr invalid."); +GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_EXEC_MODEL_QUEUE_ID_INVALID, "Queue id of model invalid."); +GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_EXEC_LOAD_MODEL_REPEATED, "The model loaded repeatedly."); +GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_EXEC_MODEL_PARTITION_NUM_INVALID, "Model partition num invalid."); +GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_DYNAMIC_INPUT_ADDR_INVALID, "Dynamic input addr invalid."); +GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID, "Dynamic input size invalid."); +GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_DYNAMIC_BATCH_SIZE_INVALID, "Dynamic batch size invalid."); +GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_AIPP_BATCH_EMPTY, "AIPP batch parameter empty."); +GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_AIPP_NOT_EXIST, "AIPP parameter not exist."); +GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_AIPP_MODE_INVALID, "AIPP mode invalid."); +GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_OP_TASK_TYPE_INVALID, "Task type invalid."); +GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_OP_KERNEL_TYPE_INVALID, "Kernel type invalid."); + +GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_MEMORY_ALLOCATION, "Memory allocation error."); + +GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_INTERNAL_ERROR, "Internal error."); +GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_LOAD_MODEL, "Load model error."); +GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_EXEC_LOAD_MODEL_PARTITION_FAILED, "Failed to load model partition."); +GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_EXEC_LOAD_WEIGHT_PARTITION_FAILED, "Failed to load weight partition."); +GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_EXEC_LOAD_TASK_PARTITION_FAILED, "Failed to load task partition."); +GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_EXEC_LOAD_KERNEL_PARTITION_FAILED, "Failed to load op kernel partition."); +GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_EXEC_RELEASE_MODEL_DATA, "Failed to release the model data."); +GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_COMMAND_HANDLE, "Command handle error."); +GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_GET_TENSOR_INFO, "Get tensor info error."); +GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_UNLOAD_MODEL, "Load model error."); + } // namespace ge #endif // INC_EXTERNAL_GE_GE_API_ERROR_CODES_H_ diff --git a/inc/external/ge/ge_error_codes.h b/inc/external/ge/ge_error_codes.h new file mode 100644 index 00000000..30631d8b --- /dev/null +++ b/inc/external/ge/ge_error_codes.h @@ -0,0 +1,58 @@ +/** + * 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_EXTERNAL_GE_GE_ERROR_CODES_H_ +#define INC_EXTERNAL_GE_GE_ERROR_CODES_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif +static const uint32_t ACL_ERROR_GE_PARAM_INVALID = 145000; +static const uint32_t ACL_ERROR_GE_EXEC_NOT_INIT = 145001; +static const uint32_t ACL_ERROR_GE_EXEC_MODEL_PATH_INVALID = 145002; +static const uint32_t ACL_ERROR_GE_EXEC_MODEL_ID_INVALID = 145003; +static const uint32_t ACL_ERROR_GE_EXEC_MODEL_KEY_PATH_INVALID = 145004; +static const uint32_t ACL_ERROR_GE_EXEC_MODEL_NOT_SUPPORT_ENCRYPTION = 145005; +static const uint32_t ACL_ERROR_GE_EXEC_MODEL_DATA_SIZE_INVALID = 145006; +static const uint32_t ACL_ERROR_GE_EXEC_MODEL_ADDR_INVALID = 145007; +static const uint32_t ACL_ERROR_GE_EXEC_MODEL_QUEUE_ID_INVALID = 145008; +static const uint32_t ACL_ERROR_GE_EXEC_LOAD_MODEL_REPEATED = 145009; +static const uint32_t ACL_ERROR_GE_EXEC_MODEL_PARTITION_NUM_INVALID = 145010; +static const uint32_t ACL_ERROR_GE_DYNAMIC_INPUT_ADDR_INVALID = 145011; +static const uint32_t ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID = 145012; +static const uint32_t ACL_ERROR_GE_DYNAMIC_BATCH_SIZE_INVALID = 145013; +static const uint32_t ACL_ERROR_GE_AIPP_BATCH_EMPTY = 145014; +static const uint32_t ACL_ERROR_GE_AIPP_NOT_EXIST = 145015; +static const uint32_t ACL_ERROR_GE_AIPP_MODE_INVALID = 145016; +static const uint32_t ACL_ERROR_GE_OP_TASK_TYPE_INVALID = 145017; +static const uint32_t ACL_ERROR_GE_OP_KERNEL_TYPE_INVALID = 145018; +static const uint32_t ACL_ERROR_GE_MEMORY_ALLOCATION = 245000; +static const uint32_t ACL_ERROR_GE_INTERNAL_ERROR = 545000; +static const uint32_t ACL_ERROR_GE_LOAD_MODEL = 545001; +static const uint32_t ACL_ERROR_GE_EXEC_LOAD_MODEL_PARTITION_FAILED = 545002; +static const uint32_t ACL_ERROR_GE_EXEC_LOAD_WEIGHT_PARTITION_FAILED = 545003; +static const uint32_t ACL_ERROR_GE_EXEC_LOAD_TASK_PARTITION_FAILED = 545004; +static const uint32_t ACL_ERROR_GE_EXEC_LOAD_KERNEL_PARTITION_FAILED = 545005; +static const uint32_t ACL_ERROR_GE_EXEC_RELEASE_MODEL_DATA = 545006; +static const uint32_t ACL_ERROR_GE_COMMAND_HANDLE = 545007; +static const uint32_t ACL_ERROR_GE_GET_TENSOR_INFO = 545008; +static const uint32_t ACL_ERROR_GE_UNLOAD_MODEL = 545009; +#ifdef __cplusplus +} // namespace ge +#endif +#endif // INC_EXTERNAL_GE_GE_ERROR_CODES_H_ diff --git a/metadef b/metadef index be949d5f..ba04e25e 160000 --- a/metadef +++ b/metadef @@ -1 +1 @@ -Subproject commit be949d5ff32baec332aa8765d2b211334ae84dbf +Subproject commit ba04e25e878af2ac5f9a697806daee0768ae3bad diff --git a/parser b/parser index d865fa6e..308e3587 160000 --- a/parser +++ b/parser @@ -1 +1 @@ -Subproject commit d865fa6e67c00c536e6df2f86d4912c1f1feff4c +Subproject commit 308e3587ec54fdd32ed7113d64a1335208701f59