@@ -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) { | 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) { | 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_) { | 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) { | 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_); | 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<ModelPartitionTable *>(model_addr_tmp_); | auto partition_table = reinterpret_cast<ModelPartitionTable *>(model_addr_tmp_); | ||||
if (partition_table->num == kOriginalOmPartitionNum) { | if (partition_table->num == kOriginalOmPartitionNum) { | ||||
model_addr_tmp_ = nullptr; | 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 | // Encrypt model need to del temp model/no encrypt model don't need to del model | ||||
model_addr_tmp_ = nullptr; | model_addr_tmp_ = nullptr; | ||||
@@ -321,23 +321,23 @@ Status ModelHelper::GenerateGeModel(OmFileLoadHelper &om_load_helper) { | |||||
GE_CHECK_NOTNULL(model_); | GE_CHECK_NOTNULL(model_); | ||||
Status ret = LoadModelData(om_load_helper); | Status ret = LoadModelData(om_load_helper); | ||||
if (ret != SUCCESS) { | if (ret != SUCCESS) { | ||||
return GE_EXEC_LOAD_MODEL_PARTITION_FAILED; | |||||
return ACL_ERROR_GE_EXEC_LOAD_MODEL_PARTITION_FAILED; | |||||
} | } | ||||
ret = LoadWeights(om_load_helper); | ret = LoadWeights(om_load_helper); | ||||
if (ret != SUCCESS) { | if (ret != SUCCESS) { | ||||
return GE_EXEC_LOAD_WEIGHT_PARTITION_FAILED; | |||||
return ACL_ERROR_GE_EXEC_LOAD_WEIGHT_PARTITION_FAILED; | |||||
} | } | ||||
ret = LoadTask(om_load_helper); | ret = LoadTask(om_load_helper); | ||||
if (ret != SUCCESS) { | if (ret != SUCCESS) { | ||||
return GE_EXEC_LOAD_TASK_PARTITION_FAILED; | |||||
return ACL_ERROR_GE_EXEC_LOAD_TASK_PARTITION_FAILED; | |||||
} | } | ||||
ret = LoadTBEKernelStore(om_load_helper); | ret = LoadTBEKernelStore(om_load_helper); | ||||
if (ret != SUCCESS) { | if (ret != SUCCESS) { | ||||
return GE_EXEC_LOAD_KERNEL_PARTITION_FAILED; | |||||
return ACL_ERROR_GE_EXEC_LOAD_KERNEL_PARTITION_FAILED; | |||||
} | } | ||||
ret = LoadCustAICPUKernelStore(om_load_helper); | ret = LoadCustAICPUKernelStore(om_load_helper); | ||||
if (ret != SUCCESS) { | if (ret != SUCCESS) { | ||||
return GE_EXEC_LOAD_KERNEL_PARTITION_FAILED; | |||||
return ACL_ERROR_GE_EXEC_LOAD_KERNEL_PARTITION_FAILED; | |||||
} | } | ||||
return SUCCESS; | return SUCCESS; | ||||
} | } | ||||
@@ -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) { | Status OmFileLoadHelper::LoadModelPartitionTable(uint8_t *model_data, const uint32_t model_data_size) { | ||||
if (model_data == nullptr) { | 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 | // Init partition table | ||||
auto partition_table = reinterpret_cast<ModelPartitionTable *>(model_data); | auto partition_table = reinterpret_cast<ModelPartitionTable *>(model_data); | ||||
@@ -119,16 +119,16 @@ Status OmFileLoadHelper::LoadModelPartitionTable(uint8_t *model_data, const uint | |||||
// Original model partition include graph-info | // Original model partition include graph-info | ||||
if ((partition_table->num != PARTITION_SIZE) && (partition_table->num != (PARTITION_SIZE - 1)) && | if ((partition_table->num != PARTITION_SIZE) && (partition_table->num != (PARTITION_SIZE - 1)) && | ||||
(partition_table->num != (PARTITION_SIZE - kOptionalNum)) && (partition_table->num != 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); | size_t mem_offset = SIZE_OF_MODEL_PARTITION_TABLE(*partition_table); | ||||
GELOGI("ModelPartitionTable num :%u, ModelFileHeader length :%zu, ModelPartitionTable length :%zu", | GELOGI("ModelPartitionTable num :%u, ModelFileHeader length :%zu, ModelPartitionTable length :%zu", | ||||
partition_table->num, sizeof(ModelFileHeader), mem_offset); | partition_table->num, sizeof(ModelFileHeader), mem_offset); | ||||
if (model_data_size <= 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); | 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++) { | for (uint32_t i = 0; i < partition_table->num; i++) { | ||||
ModelPartition partition; | ModelPartition partition; | ||||
@@ -138,9 +138,9 @@ Status OmFileLoadHelper::LoadModelPartitionTable(uint8_t *model_data, const uint | |||||
context_.partition_datas_.push_back(partition); | context_.partition_datas_.push_back(partition); | ||||
if (partition.size > model_data_size || mem_offset > model_data_size - partition.size) { | 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); | 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; | mem_offset += partition.size; | ||||
GELOGI("Partition, type:%d, size:%u", static_cast<int>(partition.type), partition.size); | GELOGI("Partition, type:%d, size:%u", static_cast<int>(partition.type), partition.size); | ||||
@@ -36,18 +36,18 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelParserBase::LoadFro | |||||
std::string real_path = RealPath(model_path); | std::string real_path = RealPath(model_path); | ||||
if (real_path.empty()) { | if (real_path.empty()) { | ||||
GELOGE(GE_EXEC_MODEL_PATH_INVALID, "Model file path '%s' is invalid", model_path); | 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) { | 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); | std::ifstream fs(real_path.c_str(), std::ifstream::binary); | ||||
if (!fs.is_open()) { | 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: | // 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]; | char *data = new (std::nothrow) char[len]; | ||||
if (data == nullptr) { | 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: | // 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); | GE_CHECK_NOTNULL(model.model_data); | ||||
// Model length too small | // 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, | "Invalid model. Model data size %u must be greater than or equal to %zu.", model.model_len, | ||||
sizeof(ModelFileHeader)); | sizeof(ModelFileHeader)); | ||||
// Get file header | // 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 | // Determine whether the file length and magic number match | ||||
GE_CHK_BOOL_RET_STATUS( | GE_CHK_BOOL_RET_STATUS( | ||||
file_header->length == model.model_len - sizeof(ModelFileHeader) && file_header->magic == MODEL_FILE_MAGIC_NUM, | 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] || " | "Invalid model. file_header->length[%u] + sizeof(ModelFileHeader)[%zu] != model->model_len[%u] || " | ||||
"MODEL_FILE_MAGIC_NUM[%u] != file_header->magic[%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); | 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 | // Get data address | ||||
uint8_t *data = reinterpret_cast<uint8_t *>(model.model_data) + sizeof(ModelFileHeader); | uint8_t *data = reinterpret_cast<uint8_t *>(model.model_data) + sizeof(ModelFileHeader); | ||||
if (file_header->is_encrypt == ModelEncryptType::UNENCRYPTED) { // Unencrypted model | 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."); | "Invalid param. model is unencrypted, but key is not empty."); | ||||
model_data = data; | model_data = data; | ||||
model_len = file_header->length; | model_len = file_header->length; | ||||
GELOGI("Model_len is %u, model_file_head_len is %zu.", model_len, sizeof(ModelFileHeader)); | GELOGI("Model_len is %u, model_file_head_len is %zu.", model_len, sizeof(ModelFileHeader)); | ||||
} else { | } 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; | return res; | ||||
@@ -50,19 +50,6 @@ const size_t kDynamicImageSizeVecSize = 2; | |||||
const size_t kDynamicImageSizeInputSize = 2; | const size_t kDynamicImageSizeInputSize = 2; | ||||
const char *const kBatchLabel = "Batch_"; | 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::TensorDesc> &ge_descs, | void GetGeTensorDescFromDomiInfo(std::vector<ge::TensorDesc> &ge_descs, | ||||
const std::vector<ge::InputOutputDescInfo> &domi_descs, | const std::vector<ge::InputOutputDescInfo> &domi_descs, | ||||
const std::vector<uint32_t> &formats) { | const std::vector<uint32_t> &formats) { | ||||
@@ -286,14 +273,14 @@ Status GeExecutor::Finalize() { | |||||
Status GeExecutor::SetDynamicBatchSize(uint32_t model_id, void *dynamic_input_addr, uint64_t length, | Status GeExecutor::SetDynamicBatchSize(uint32_t model_id, void *dynamic_input_addr, uint64_t length, | ||||
uint64_t batch_size) { | uint64_t batch_size) { | ||||
if (dynamic_input_addr == nullptr) { | 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); | uint64_t size = sizeof(uint32_t); | ||||
if (length < size) { | 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)) { | if (length >= sizeof(uint64_t)) { | ||||
size = 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)) { | 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<int32_t>(DYNAMIC_BATCH)); | ret = GraphExecutor::SetDynamicSize(model_id, batch_num, static_cast<int32_t>(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 | // 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); | rtError_t rt_ret = rtMemcpy(dynamic_input_addr, length, &batch_size, size, RT_MEMCPY_HOST_TO_DEVICE); | ||||
if (rt_ret != RT_ERROR_NONE) { | 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 RT_ERROR_TO_GE_STATUS(rt_ret); | ||||
} | } | ||||
return SUCCESS; | 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, | Status GeExecutor::SetDynamicImageSize(uint32_t model_id, void *dynamic_input_addr, uint64_t length, | ||||
uint64_t image_height, uint64_t image_width) { | uint64_t image_height, uint64_t image_width) { | ||||
if (dynamic_input_addr == nullptr) { | 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); | uint64_t dynamic_input_size = kDynamicImageSizeInputSize * sizeof(uint32_t); | ||||
if (length < dynamic_input_size) { | 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); | uint64_t size = sizeof(uint32_t); | ||||
if (length >= kDynamicImageSizeInputSize * sizeof(uint64_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)) { | 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<int32_t>(DYNAMIC_IMAGE)); | ret = GraphExecutor::SetDynamicSize(model_id, batch_num, static_cast<int32_t>(DYNAMIC_IMAGE)); | ||||
@@ -365,20 +353,21 @@ Status GeExecutor::SetDynamicImageSize(uint32_t model_id, void *dynamic_input_ad | |||||
return ret; | return ret; | ||||
} | } | ||||
// Memcpy dynamic resolution height from host to device | |||||
// Memcpy dynamic resolution height from host to device | |||||
rtError_t rt_ret = | rtError_t rt_ret = | ||||
rtMemcpy(dynamic_input_addr, size, &image_height, size, RT_MEMCPY_HOST_TO_DEVICE); | rtMemcpy(dynamic_input_addr, size, &image_height, size, RT_MEMCPY_HOST_TO_DEVICE); | ||||
if (rt_ret != RT_ERROR_NONE) { | 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); | return RT_ERROR_TO_GE_STATUS(rt_ret); | ||||
} | } | ||||
uint64_t remain_size = length - size; | uint64_t remain_size = length - size; | ||||
// Memcpy dynamic resolution width from host to device | // Memcpy dynamic resolution width from host to device | ||||
if (rtMemcpy(reinterpret_cast<void *>(reinterpret_cast<uint8_t *>(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<void *>(reinterpret_cast<uint8_t *>(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; | 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, | Status GeExecutor::SetDynamicDims(uint32_t model_id, void *dynamic_input_addr, uint64_t length, | ||||
const vector<uint64_t> &dynamic_dims) { | const vector<uint64_t> &dynamic_dims) { | ||||
if (dynamic_input_addr == nullptr) { | 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<uint64_t> cur_dynamic_dims; | vector<uint64_t> cur_dynamic_dims; | ||||
Status ret = GetCurDynamicDims(model_id, dynamic_dims, cur_dynamic_dims); | Status ret = GetCurDynamicDims(model_id, dynamic_dims, cur_dynamic_dims); | ||||
if (ret != SUCCESS) { | 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<std::vector<int64_t>> batch_info; | std::vector<std::vector<int64_t>> batch_info; | ||||
int32_t dynamic_type = static_cast<int32_t>(FIXED); | int32_t dynamic_type = static_cast<int32_t>(FIXED); | ||||
@@ -405,32 +394,35 @@ Status GeExecutor::SetDynamicDims(uint32_t model_id, void *dynamic_input_addr, u | |||||
} | } | ||||
if (!IsDynmaicDimsSizeMatchModel(cur_dynamic_dims, batch_info)) { | 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<int32_t>(DYNAMIC_DIMS)); | ret = GraphExecutor::SetDynamicSize(model_id, cur_dynamic_dims, static_cast<int32_t>(DYNAMIC_DIMS)); | ||||
if (ret != SUCCESS) { | 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(); | size_t dynamic_dim_num = cur_dynamic_dims.size(); | ||||
uint64_t dynamic_input_size = static_cast<uint64_t>(dynamic_dim_num * sizeof(uint32_t)); | uint64_t dynamic_input_size = static_cast<uint64_t>(dynamic_dim_num * sizeof(uint32_t)); | ||||
if (length < dynamic_input_size) { | 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); | uint64_t size = sizeof(uint32_t); | ||||
if (length >= dynamic_dim_num * sizeof(uint64_t)) { | if (length >= dynamic_dim_num * sizeof(uint64_t)) { | ||||
size = sizeof(uint64_t); | size = sizeof(uint64_t); | ||||
} | } | ||||
rtError_t rt_ret; | |||||
for (uint32_t i = 0; i < dynamic_dim_num; ++i) { | for (uint32_t i = 0; i < dynamic_dim_num; ++i) { | ||||
// Memcpy dynamic dim[i] from host to device | // Memcpy dynamic dim[i] from host to device | ||||
if (rtMemcpy(reinterpret_cast<void *>(reinterpret_cast<uint8_t *>(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<void *>(reinterpret_cast<uint8_t *>(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; | return SUCCESS; | ||||
@@ -443,15 +435,15 @@ Status GeExecutor::GetCurDynamicDims(uint32_t model_id, const vector<uint64_t> & | |||||
vector<ge::TensorDesc> output_desc; | vector<ge::TensorDesc> output_desc; | ||||
auto ret = GetModelDescInfo(model_id, input_desc, output_desc); | auto ret = GetModelDescInfo(model_id, input_desc, output_desc); | ||||
if (ret != ge::SUCCESS) { | if (ret != ge::SUCCESS) { | ||||
GELOGE(FAILED, "GetModelDescInfo failed."); | |||||
return FAILED; | |||||
GELOGE(ret, "GetModelDescInfo failed."); | |||||
return ret; | |||||
} | } | ||||
vector<string> user_designate_shape_order; | vector<string> user_designate_shape_order; | ||||
vector<int64_t> all_data_dims; | vector<int64_t> all_data_dims; | ||||
ret = GetUserDesignateShapeOrder(model_id, user_designate_shape_order); | ret = GetUserDesignateShapeOrder(model_id, user_designate_shape_order); | ||||
if (ret != ge::SUCCESS) { | 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 &data_name : user_designate_shape_order) { | ||||
for (auto &desc : input_desc) { | for (auto &desc : input_desc) { | ||||
@@ -464,17 +456,18 @@ Status GeExecutor::GetCurDynamicDims(uint32_t model_id, const vector<uint64_t> & | |||||
} | } | ||||
} | } | ||||
if (dynamic_dims.size() != all_data_dims.size()){ | 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()); | 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) { | for (std::size_t i = 0; i < all_data_dims.size(); ++i) { | ||||
if (all_data_dims[i] < 0) { | if (all_data_dims[i] < 0) { | ||||
cur_dynamic_dims.push_back(dynamic_dims[i]); | cur_dynamic_dims.push_back(dynamic_dims[i]); | ||||
} else if (static_cast<uint64_t>(all_data_dims[i]) != dynamic_dims[i]) { | } else if (static_cast<uint64_t>(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]); | i, dynamic_dims[i], all_data_dims[i]); | ||||
return PARAM_INVALID; | |||||
return ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID; | |||||
} | } | ||||
} | } | ||||
return SUCCESS; | return SUCCESS; | ||||
@@ -483,8 +476,8 @@ Status GeExecutor::GetCurDynamicDims(uint32_t model_id, const vector<uint64_t> & | |||||
Status GeExecutor::GetCurShape(const uint32_t model_id, std::vector<int64_t> &batch_info, int32_t &dynamic_type) { | Status GeExecutor::GetCurShape(const uint32_t model_id, std::vector<int64_t> &batch_info, int32_t &dynamic_type) { | ||||
GELOGI("Begin to get current shape"); | GELOGI("Begin to get current shape"); | ||||
if (!isInit_) { | 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); | Status ret = GraphExecutor::GetCurShape(model_id, batch_info, dynamic_type); | ||||
if (ret != SUCCESS) { | if (ret != SUCCESS) { | ||||
@@ -499,12 +492,12 @@ Status GeExecutor::SetDynamicAippData(uint32_t model_id, void *dynamic_input_add | |||||
const kAippDynamicPara &aippParms) { | const kAippDynamicPara &aippParms) { | ||||
GELOGI("Enter to SetDynamicAippData."); | GELOGI("Enter to SetDynamicAippData."); | ||||
if (dynamic_input_addr == nullptr) { | 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()) { | 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 batch_num = aippBatchPara.size(); | ||||
uint64_t real_aippParms_size = sizeof(kAippDynamicPara) - sizeof(kAippDynamicBatchPara); | 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", | "batch num is %lu, struct_len is %lu", | ||||
model_id, length, batch_num, struct_len); | model_id, length, batch_num, struct_len); | ||||
if (struct_len > length) { | 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 | // 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); | rtError_t rt_ret = rtMemcpy(dynamic_input_addr, length, &aippParms, real_aippParms_size, RT_MEMCPY_HOST_TO_DEVICE); | ||||
if (rt_ret != RT_ERROR_NONE) { | 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); | return RT_ERROR_TO_GE_STATUS(rt_ret); | ||||
} | } | ||||
uint64_t remain_len = length - real_aippParms_size; | 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]), | (remain_len - i * sizeof(kAippDynamicBatchPara)), &(aippBatchPara[i]), | ||||
sizeof(kAippDynamicBatchPara), RT_MEMCPY_HOST_TO_DEVICE); | sizeof(kAippDynamicBatchPara), RT_MEMCPY_HOST_TO_DEVICE); | ||||
if (rt_ret != RT_ERROR_NONE) { | 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); | 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<ge::ModelListener> listener) { | int32_t priority, std::shared_ptr<ge::ModelListener> listener) { | ||||
GELOGI("load model offline begin."); | GELOGI("load model offline begin."); | ||||
if (!isInit_) { | 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()); | string filePath = RealPath(path.c_str()); | ||||
if (filePath.empty()) { | 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<ModelListenerAdapter> listener_adapter = MakeShared<ModelListenerAdapter>(); | std::shared_ptr<ModelListenerAdapter> listener_adapter = MakeShared<ModelListenerAdapter>(); | ||||
if (listener_adapter == nullptr) { | 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; | listener_adapter->listener = listener; | ||||
Status ret = GraphLoader::LoadModelFromFile(path, key, priority, listener_adapter, model_id); | Status ret = GraphLoader::LoadModelFromFile(path, key, priority, listener_adapter, model_id); | ||||
if (ret != SUCCESS) { | if (ret != SUCCESS) { | ||||
GELOGE(ret, "[GeExecutor] LoadModelFromFile failed"); | GELOGE(ret, "[GeExecutor] LoadModelFromFile failed"); | ||||
return TransferDomiErrorCode(ret); | |||||
return ACL_ERROR_GE_LOAD_MODEL; | |||||
} | } | ||||
return SUCCESS; | return SUCCESS; | ||||
} | } | ||||
@@ -572,21 +567,21 @@ Status GeExecutor::LoadModel(uint32_t &model_id, const ModelData &model_data, | |||||
std::shared_ptr<ge::ModelListener> listener) { | std::shared_ptr<ge::ModelListener> listener) { | ||||
GELOGI("Load model begin."); | GELOGI("Load model begin."); | ||||
if (!isInit_) { | 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<ModelListenerAdapter> listener_adapter = MakeShared<ModelListenerAdapter>(); | std::shared_ptr<ModelListenerAdapter> listener_adapter = MakeShared<ModelListenerAdapter>(); | ||||
if (listener_adapter == nullptr) { | 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; | listener_adapter->listener = listener; | ||||
Status ret = GraphLoader::LoadModel(model_data, listener_adapter, model_id); | Status ret = GraphLoader::LoadModel(model_data, listener_adapter, model_id); | ||||
if (ret != SUCCESS) { | if (ret != SUCCESS) { | ||||
GELOGE(ret, "[GeExecutor] LoadModel failed."); | GELOGE(ret, "[GeExecutor] LoadModel failed."); | ||||
return TransferDomiErrorCode(ret); | |||||
return ACL_ERROR_GE_LOAD_MODEL; | |||||
} | } | ||||
return ret; | return ret; | ||||
} | } | ||||
@@ -594,13 +589,13 @@ Status GeExecutor::LoadModel(uint32_t &model_id, const ModelData &model_data, | |||||
Status GeExecutor::UnloadModel(uint32_t model_id) { | Status GeExecutor::UnloadModel(uint32_t model_id) { | ||||
GELOGI("unload model %u begin.", model_id); | GELOGI("unload model %u begin.", model_id); | ||||
if (!isInit_) { | 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); | Status ret = GraphLoader::DestroyAicpuSessionForInfer(model_id); | ||||
if (ret != SUCCESS) { | if (ret != SUCCESS) { | ||||
GELOGE(ret, "[GraphLoader] DestroyAicpuSessionForInfer failed. model id: %u", model_id); | GELOGE(ret, "[GraphLoader] DestroyAicpuSessionForInfer failed. model id: %u", model_id); | ||||
return FAILED; | |||||
return ACL_ERROR_GE_INTERNAL_ERROR; | |||||
} | } | ||||
std::shared_ptr<DavinciModel> davinci_model = ModelManager::GetInstance()->GetModel(model_id); | std::shared_ptr<DavinciModel> 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(); | uint64_t session_id = davinci_model->GetSessionId(); | ||||
VarManagerPool::Instance().RemoveVarManager(session_id); | 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) { | Status GeExecutor::RunModel(const ge::RunModelData &input_data, ge::RunModelData &output_data) { | ||||
GELOGI("run model begin."); | GELOGI("run model begin."); | ||||
if (!isInit_) { | 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; | InputData inputs; | ||||
@@ -631,8 +631,8 @@ Status GeExecutor::GetModelDescInfo(uint32_t model_id, std::vector<ge::TensorDes | |||||
std::vector<ge::TensorDesc> &output_desc, bool new_model_desc) { | std::vector<ge::TensorDesc> &output_desc, bool new_model_desc) { | ||||
GELOGI("get model desc info begin."); | GELOGI("get model desc info begin."); | ||||
if (!isInit_) { | 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<InputOutputDescInfo> input_desc_infos; | std::vector<InputOutputDescInfo> input_desc_infos; | ||||
@@ -644,19 +644,20 @@ Status GeExecutor::GetModelDescInfo(uint32_t model_id, std::vector<ge::TensorDes | |||||
output_formats, new_model_desc); | output_formats, new_model_desc); | ||||
if (ret != domi::SUCCESS) { | if (ret != domi::SUCCESS) { | ||||
GELOGE(ret, "GetInputOutputDescInfo failed. ret = %u", ret); | GELOGE(ret, "GetInputOutputDescInfo failed. ret = %u", ret); | ||||
return ret; | |||||
return ACL_ERROR_GE_GET_TENSOR_INFO; | |||||
} | } | ||||
if (input_formats.size() != input_desc_infos.size()) { | if (input_formats.size() != input_desc_infos.size()) { | ||||
GELOGE(ge::PARAM_INVALID, "input_formats size %zu is not equal to input_desc_infos size %zu.", input_formats.size(), | |||||
input_desc_infos.size()); | |||||
return ge::PARAM_INVALID; | |||||
GELOGE(ACL_ERROR_GE_PARAM_INVALID, | |||||
"input_formats size %zu is not equal to input_desc_infos size %zu.", | |||||
input_formats.size(), input_desc_infos.size()); | |||||
return ACL_ERROR_GE_PARAM_INVALID; | |||||
} | } | ||||
if (output_formats.size() != output_desc_infos.size()) { | if (output_formats.size() != output_desc_infos.size()) { | ||||
GELOGE(ge::PARAM_INVALID, "output_formats size %zu is not equal to output_desc_infos size %zu.", | |||||
GELOGE(ACL_ERROR_GE_PARAM_INVALID, "output_formats size %zu is not equal to output_desc_infos size %zu.", | |||||
output_formats.size(), output_desc_infos.size()); | output_formats.size(), output_desc_infos.size()); | ||||
return ge::PARAM_INVALID; | |||||
return ACL_ERROR_GE_PARAM_INVALID; | |||||
} | } | ||||
// Transfer data to TensorDesc | // Transfer data to TensorDesc | ||||
@@ -679,8 +680,8 @@ Status GeExecutor::GetDynamicBatchInfo(uint32_t model_id, std::vector<std::vecto | |||||
int32_t &dynamic_type) { | int32_t &dynamic_type) { | ||||
GELOGI("Begin to get dynamic batch info."); | GELOGI("Begin to get dynamic batch info."); | ||||
if (!isInit_) { | 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::GetDynamicBatchInfo(model_id, batch_info, dynamic_type); | Status ret = GraphExecutor::GetDynamicBatchInfo(model_id, batch_info, dynamic_type); | ||||
@@ -703,8 +704,8 @@ Status GeExecutor::GetDynamicBatchInfo(uint32_t model_id, std::vector<std::vecto | |||||
Status GeExecutor::GetCombinedDynamicDims(uint32_t model_id, vector<vector<int64_t>> &batch_info) { | Status GeExecutor::GetCombinedDynamicDims(uint32_t model_id, vector<vector<int64_t>> &batch_info) { | ||||
GELOGI("Begin to get combined dynamic dims info."); | GELOGI("Begin to get combined dynamic dims info."); | ||||
if (!isInit_) { | 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); | Status ret = GraphExecutor::GetCombinedDynamicDims(model_id, batch_info); | ||||
@@ -727,8 +728,8 @@ Status GeExecutor::GetCombinedDynamicDims(uint32_t model_id, vector<vector<int64 | |||||
Status GeExecutor::GetUserDesignateShapeOrder(uint32_t model_id, vector<string> &user_designate_shape_order) { | Status GeExecutor::GetUserDesignateShapeOrder(uint32_t model_id, vector<string> &user_designate_shape_order) { | ||||
GELOGI("Begin to get user designate shape info."); | GELOGI("Begin to get user designate shape info."); | ||||
if (!isInit_) { | 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); | Status ret = GraphExecutor::GetUserDesignateShapeOrder(model_id, user_designate_shape_order); | ||||
@@ -752,8 +753,8 @@ Status GeExecutor::GetUserDesignateShapeOrder(uint32_t model_id, vector<string> | |||||
Status GeExecutor::GetAIPPInfo(uint32_t model_id, uint32_t index, AippConfigInfo &aipp_info) { | Status GeExecutor::GetAIPPInfo(uint32_t model_id, uint32_t index, AippConfigInfo &aipp_info) { | ||||
GELOGI("Begin to GetAIPPInfo."); | GELOGI("Begin to GetAIPPInfo."); | ||||
if (!isInit_) { | 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); | Status ret = GraphExecutor::GetAIPPInfo(model_id, index, aipp_info); | ||||
if (ret != SUCCESS) { | 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) { | Status GeExecutor::GetAippType(uint32_t model_id, uint32_t index, InputAippType &type, size_t &aipp_index) { | ||||
GELOGI("Begin to get aipp type."); | GELOGI("Begin to get aipp type."); | ||||
if (!isInit_) { | 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); | Status ret = GraphExecutor::GetAippType(model_id, index, type, aipp_index); | ||||
if (ret != SUCCESS) { | 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<std::string> &dynamic_output_shape_info) { | Status GeExecutor::GetModelAttr(uint32_t model_id, std::vector<std::string> &dynamic_output_shape_info) { | ||||
GELOGI("Begin to get dynamic batch output shape info"); | GELOGI("Begin to get dynamic batch output shape info"); | ||||
if (!isInit_) { | 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); | Status ret = GraphExecutor::GetModelAttr(model_id, dynamic_output_shape_info); | ||||
if (ret != SUCCESS) { | if (ret != SUCCESS) { | ||||
@@ -799,8 +800,8 @@ Status GeExecutor::GetModelDescInfoForZeroCopy(uint32_t model_id, std::vector<ge | |||||
std::vector<TensorDesc> &output_desc) { | std::vector<TensorDesc> &output_desc) { | ||||
GELOGI("get model desc info for zero copy begin."); | GELOGI("get model desc info for zero copy begin."); | ||||
if (!isInit_) { | 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<InputOutputDescInfo> input_desc_infos; | std::vector<InputOutputDescInfo> input_desc_infos; | ||||
@@ -812,17 +813,17 @@ Status GeExecutor::GetModelDescInfoForZeroCopy(uint32_t model_id, std::vector<ge | |||||
input_formats, output_formats); | input_formats, output_formats); | ||||
if (ret != domi::SUCCESS) { | if (ret != domi::SUCCESS) { | ||||
GELOGE(ret, "Get DescInfo from zero copy failed. ret = %u", ret); | GELOGE(ret, "Get DescInfo from zero copy failed. ret = %u", ret); | ||||
return TransferDomiErrorCode(ret); | |||||
return ACL_ERROR_GE_GET_TENSOR_INFO; | |||||
} | } | ||||
if (input_formats.size() != input_desc_infos.size()) { | if (input_formats.size() != input_desc_infos.size()) { | ||||
GELOGE(ge::FAILED, "input_formats.size() != input_desc_infos.size()."); | |||||
return ge::FAILED; | |||||
GELOGE(ACL_ERROR_GE_PARAM_INVALID, "input_formats.size() != input_desc_infos.size()."); | |||||
return ACL_ERROR_GE_PARAM_INVALID; | |||||
} | } | ||||
if (output_formats.size() != output_desc_infos.size()) { | if (output_formats.size() != output_desc_infos.size()) { | ||||
GELOGE(ge::FAILED, "output_formats.size() != output_desc_infos.size()."); | |||||
return ge::FAILED; | |||||
GELOGE(ACL_ERROR_GE_PARAM_INVALID, "output_formats.size() != output_desc_infos.size()."); | |||||
return ACL_ERROR_GE_PARAM_INVALID; | |||||
} | } | ||||
GetGeTensorDescFromDomiInfo(input_desc, input_desc_infos, input_formats); | GetGeTensorDescFromDomiInfo(input_desc, input_desc_infos, input_formats); | ||||
@@ -837,8 +838,8 @@ Status GeExecutor::CommandHandle(const Command &command) { | |||||
Status ret = GraphLoader::CommandHandle(command); | Status ret = GraphLoader::CommandHandle(command); | ||||
if (ret != SUCCESS) { | if (ret != SUCCESS) { | ||||
GELOGE(ret, "CommandHandle: Command Handle failed."); | |||||
return TransferDomiErrorCode(ret); | |||||
GELOGE(ACL_ERROR_GE_COMMAND_HANDLE, "CommandHandle: Command Handle failed."); | |||||
return ACL_ERROR_GE_COMMAND_HANDLE; | |||||
} | } | ||||
return SUCCESS; | return SUCCESS; | ||||
} | } | ||||
@@ -846,8 +847,8 @@ Status GeExecutor::CommandHandle(const Command &command) { | |||||
Status GeExecutor::GetMaxUsedMemory(uint32_t model_id, uint32_t &max_size) { | Status GeExecutor::GetMaxUsedMemory(uint32_t model_id, uint32_t &max_size) { | ||||
GELOGI("Get max used memory begin."); | GELOGI("Get max used memory begin."); | ||||
if (!isInit_) { | 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; | |||||
} | } | ||||
uint64_t max_mem_size = 0; | uint64_t max_mem_size = 0; | ||||
@@ -866,14 +867,15 @@ Status GeExecutor::GetMaxUsedMemory(uint32_t model_id, uint32_t &max_size) { | |||||
Status GeExecutor::LoadDataFromFile(const std::string &path, ModelData &model_data) { | Status GeExecutor::LoadDataFromFile(const std::string &path, ModelData &model_data) { | ||||
GELOGI("Load data from file begin."); | GELOGI("Load data from file begin."); | ||||
if (!isInit_) { | 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()); | string filePath = RealPath(path.c_str()); | ||||
if (filePath.empty()) { | if (filePath.empty()) { | ||||
GELOGE(GE_EXEC_MODEL_PATH_INVALID, "File path is invalid. please check your text file '%s'.", path.c_str()); | |||||
return GE_EXEC_MODEL_PATH_INVALID; | |||||
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; | |||||
} | } | ||||
GELOGI("load modelData from file: %s.", path.c_str()); | GELOGI("load modelData from file: %s.", path.c_str()); | ||||
std::string key_path; | std::string key_path; | ||||
@@ -903,8 +905,8 @@ Status GeExecutor::LoadModelFromData(uint32_t &model_id, const ModelData &model_ | |||||
void *weight_ptr, size_t weight_size) { | void *weight_ptr, size_t weight_size) { | ||||
GELOGI("Load model from data begin."); | GELOGI("Load model from data begin."); | ||||
if (!isInit_) { | 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; | |||||
} | } | ||||
return GraphLoader::LoadModelFromData(model_id, model_data, dev_ptr, mem_size, weight_ptr, weight_size); | return GraphLoader::LoadModelFromData(model_id, model_data, dev_ptr, mem_size, weight_ptr, weight_size); | ||||
@@ -924,8 +926,8 @@ Status GeExecutor::LoadModelWithQ(uint32_t &model_id, const ModelData &model_dat | |||||
const std::vector<uint32_t> &output_queue_ids) { | const std::vector<uint32_t> &output_queue_ids) { | ||||
GELOGI("Load model with queue begin."); | GELOGI("Load model with queue begin."); | ||||
if (!isInit_) { | 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); | 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) { | ge::RunModelData &run_output_data, bool async_mode) { | ||||
GELOGI("Execute model begin."); | GELOGI("Execute model begin."); | ||||
if (!isInit_) { | 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; | 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) { | Status GeExecutor::GetMemAndWeightSize(const std::string &path, size_t &mem_size, size_t &weight_size) { | ||||
GELOGI("Get memory and weight size from file begin."); | GELOGI("Get memory and weight size from file begin."); | ||||
if (!isInit_) { | 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; | ModelData model; | ||||
@@ -1014,13 +1016,13 @@ Status GeExecutor::GetMemAndWeightSize(const void *model_data, size_t model_size | |||||
size_t &weight_size) { | size_t &weight_size) { | ||||
GELOGI("Get memory and weight size from data begin."); | GELOGI("Get memory and weight size from data begin."); | ||||
if (!isInit_) { | 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) { | 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; | ModelData model; | ||||
@@ -1043,8 +1045,8 @@ Status GeExecutor::LoadDynamicSingleOp(const std::string &model_name, const ge:: | |||||
Status GeExecutor::ExecuteAsync(SingleOp *executor, const std::vector<DataBuffer> &inputs, | Status GeExecutor::ExecuteAsync(SingleOp *executor, const std::vector<DataBuffer> &inputs, | ||||
std::vector<DataBuffer> &outputs) { | std::vector<DataBuffer> &outputs) { | ||||
if (executor == nullptr) { | 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); | 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); | GE_CHECK_NOTNULL(model_manager); | ||||
auto davinci_model = model_manager->GetModel(model_id); | auto davinci_model = model_manager->GetModel(model_id); | ||||
if (davinci_model == nullptr) { | 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(); | 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) { | Status GeExecutor::GetOrigInputInfo(uint32_t model_id, uint32_t index, OriginInputInfo &orig_input_info) { | ||||
GELOGI("Begin to GetOrigInputInfo."); | GELOGI("Begin to GetOrigInputInfo."); | ||||
if (!isInit_) { | 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); | 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<InputOutputDims> &output_dims) { | std::vector<InputOutputDims> &output_dims) { | ||||
GELOGI("Begin to GetAllAippInputOutputDims."); | GELOGI("Begin to GetAllAippInputOutputDims."); | ||||
if (!isInit_) { | 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); | Status ret = GraphExecutor::GetAllAippInputOutputDims(model_id, index, input_dims, output_dims); | ||||
@@ -91,7 +91,7 @@ Status GraphExecutor::SetDynamicSize(uint32_t model_id, const std::vector<uint64 | |||||
GE_CHECK_NOTNULL(model_manager); | GE_CHECK_NOTNULL(model_manager); | ||||
Status ret = model_manager->SetDynamicSize(model_id, batch_num, dynamic_type); | Status ret = model_manager->SetDynamicSize(model_id, batch_num, dynamic_type); | ||||
if (ret != SUCCESS) { | if (ret != SUCCESS) { | ||||
GELOGE(FAILED, "SetDynamicSize failed"); | |||||
GELOGE(ret, "SetDynamicSize failed"); | |||||
return ret; | return ret; | ||||
} | } | ||||
return SUCCESS; | return SUCCESS; | ||||
@@ -212,9 +212,9 @@ Status GraphLoader::CommandHandle(const Command &command) { | |||||
return ret; | return ret; | ||||
} | } | ||||
} catch (std::bad_alloc &) { | } 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 (...) { | } catch (...) { | ||||
GELOGE(FAILED, "Command handle failed, some exceptions occur !"); | GELOGE(FAILED, "Command handle failed, some exceptions occur !"); | ||||
@@ -1502,8 +1502,8 @@ Status DavinciModel::InitVariable(const OpDescPtr &op_desc) { | |||||
Status DavinciModel::SetQueIds(const std::vector<uint32_t> &input_queue_ids, | Status DavinciModel::SetQueIds(const std::vector<uint32_t> &input_queue_ids, | ||||
const std::vector<uint32_t> &output_queue_ids) { | const std::vector<uint32_t> &output_queue_ids) { | ||||
if (input_queue_ids.empty() && output_queue_ids.empty()) { | 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; | input_queue_ids_ = input_queue_ids; | ||||
@@ -1524,15 +1524,15 @@ Status DavinciModel::LoadWithQueue() { | |||||
} | } | ||||
if (input_queue_ids_.size() != new_input_data_info_.size()) { | 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()); | 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()) { | 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()); | 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."); | 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]; | OpDescPtr data_op = data_op_list_[index]; | ||||
if (!data_op->HasAttr(ATTR_NAME_AIPP)) { | if (!data_op->HasAttr(ATTR_NAME_AIPP)) { | ||||
GELOGW("GetAIPPInfo: there is not AIPP related with index %u.", index); | 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<domi::AippOpParams> aipp_params(new (std::nothrow) domi::AippOpParams()); | std::unique_ptr<domi::AippOpParams> 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") { | } else if (data_mode == "dynamic_aipp_conf") { | ||||
type = DYNAMIC_AIPP_NODE; | type = DYNAMIC_AIPP_NODE; | ||||
} else { | } 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) { | 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) { | 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; | 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); | GE_CHK_BOOL_RET_STATUS(index < data_op_list_.size(), PARAM_INVALID, "Index %u is invalid.", index); | ||||
OpDescPtr data_op = data_op_list_[index]; | OpDescPtr data_op = data_op_list_[index]; | ||||
if (!data_op->HasAttr(ATTR_NAME_AIPP_INPUTS) || !data_op->HasAttr(ATTR_NAME_AIPP_OUTPUTS)) { | 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<std::string> inputs; | vector<std::string> inputs; | ||||
@@ -4151,8 +4152,8 @@ Status DavinciModel::GetAllAippInputOutputDims(uint32_t index, std::vector<Input | |||||
GE_CHK_BOOL_RET_STATUS(index < data_op_list_.size(), PARAM_INVALID, "Index %u is invalid.", index); | GE_CHK_BOOL_RET_STATUS(index < data_op_list_.size(), PARAM_INVALID, "Index %u is invalid.", index); | ||||
OpDescPtr data_op = data_op_list_[index]; | OpDescPtr data_op = data_op_list_[index]; | ||||
if (!data_op->HasAttr(ATTR_NAME_AIPP_INPUTS) || !data_op->HasAttr(ATTR_NAME_AIPP_OUTPUTS)) { | if (!data_op->HasAttr(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<std::string> inputs; | vector<std::string> inputs; | ||||
@@ -927,7 +927,7 @@ Status ModelManager::GetInputOutputDescInfo(const uint32_t model_id, vector<Inpu | |||||
Status ModelManager::GetDynamicBatchInfo(const uint32_t model_id, std::vector<std::vector<int64_t>> &batch_info, | Status ModelManager::GetDynamicBatchInfo(const uint32_t model_id, std::vector<std::vector<int64_t>> &batch_info, | ||||
int32_t &dynamic_type) { | int32_t &dynamic_type) { | ||||
std::shared_ptr<DavinciModel> davinci_model = GetModel(model_id); | std::shared_ptr<DavinciModel> 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); | "GetDynamicBatchInfo failed, Invalid model id %u!", model_id); | ||||
return davinci_model->GetDynamicBatchInfo(batch_info, dynamic_type); | return davinci_model->GetDynamicBatchInfo(batch_info, dynamic_type); | ||||
@@ -942,8 +942,8 @@ Status ModelManager::GetDynamicBatchInfo(const uint32_t model_id, std::vector<st | |||||
/// | /// | ||||
Status ModelManager::GetCombinedDynamicDims(const uint32_t model_id, vector<vector<int64_t>> &batch_info) { | Status ModelManager::GetCombinedDynamicDims(const uint32_t model_id, vector<vector<int64_t>> &batch_info) { | ||||
std::shared_ptr<DavinciModel> davinci_model = GetModel(model_id); | std::shared_ptr<DavinciModel> 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); | davinci_model->GetCombinedDynamicDims(batch_info); | ||||
return SUCCESS; | return SUCCESS; | ||||
@@ -959,7 +959,7 @@ Status ModelManager::GetCombinedDynamicDims(const uint32_t model_id, vector<vect | |||||
Status ModelManager::GetUserDesignateShapeOrder(const uint32_t model_id, | Status ModelManager::GetUserDesignateShapeOrder(const uint32_t model_id, | ||||
std::vector<std::string> &user_input_shape_order) { | std::vector<std::string> &user_input_shape_order) { | ||||
auto davinci_model = GetModel(model_id); | 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) | "GetUserDesignateShapeOrder Failed, Invalid Model ID %u!", model_id) | ||||
davinci_model->GetUserDesignateShapeOrder(user_input_shape_order); | davinci_model->GetUserDesignateShapeOrder(user_input_shape_order); | ||||
return SUCCESS; | 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) { | Status ModelManager::GetAIPPInfo(const uint32_t model_id, uint32_t index, AippConfigInfo &aipp_info) { | ||||
std::shared_ptr<DavinciModel> davinci_model = GetModel(model_id); | std::shared_ptr<DavinciModel> 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); | model_id); | ||||
return davinci_model->GetAIPPInfo(index, aipp_info); | 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) { | Status ModelManager::GetAippType(uint32_t model_id, uint32_t index, InputAippType &type, size_t &aipp_index) { | ||||
std::shared_ptr<DavinciModel> davinci_model = GetModel(model_id); | std::shared_ptr<DavinciModel> 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); | model_id); | ||||
return davinci_model->GetAippType(index, type, aipp_index); | 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<ModelListener> listener, | Status ModelManager::LoadModelOffline(uint32_t &model_id, const ModelData &model, shared_ptr<ModelListener> listener, | ||||
void *dev_ptr, size_t mem_size, void *weight_ptr, size_t weight_size) { | 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)); | "input key file path %s is invalid, %s", model.key.c_str(), strerror(errno)); | ||||
GenModelId(&model_id); | GenModelId(&model_id); | ||||
@@ -1054,8 +1057,8 @@ Status ModelManager::LoadModelOffline(uint32_t &model_id, const ModelData &model | |||||
try { | try { | ||||
davinci_model = std::make_shared<DavinciModel>(model.priority, listener); | davinci_model = std::make_shared<DavinciModel>(model.priority, listener); | ||||
} catch (std::bad_alloc &) { | } 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 (...) { | } catch (...) { | ||||
GELOGE(INTERNAL_ERROR, "Make shared failed since other exception raise"); | GELOGE(INTERNAL_ERROR, "Make shared failed since other exception raise"); | ||||
return INTERNAL_ERROR; | 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."); | GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(ret != SUCCESS, break, "DavinciInit failed."); | ||||
InsertModel(model_id, davinci_model); | 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); | 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<uint32_t> &input_queue_ids, | const std::vector<uint32_t> &input_queue_ids, | ||||
const std::vector<uint32_t> &output_queue_ids) { | const std::vector<uint32_t> &output_queue_ids) { | ||||
GE_CHK_BOOL_RET_STATUS(model_data.key.empty() || access(model_data.key.c_str(), F_OK) == 0, | 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)); | model_data.key.c_str(), strerror(errno)); | ||||
ModelHelper model_helper; | ModelHelper model_helper; | ||||
@@ -1134,8 +1136,8 @@ Status ModelManager::LoadModelWithQ(uint32_t &model_id, const ModelData &model_d | |||||
shared_ptr<DavinciModel> davinci_model = MakeShared<DavinciModel>(model_data.priority, nullptr); | shared_ptr<DavinciModel> davinci_model = MakeShared<DavinciModel>(model_data.priority, nullptr); | ||||
if (davinci_model == 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()); | 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<ModelPartitionTable *>(model_data); | auto partition_table = reinterpret_cast<ModelPartitionTable *>(model_data); | ||||
if (partition_table->num == 1) { | 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; | ModelPartition task_partition; | ||||
if (om_file_helper.GetModelPartition(ModelPartitionType::TASK_INFO, task_partition) != SUCCESS) { | 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<domi::ModelTaskDef> model_task_def = MakeShared<domi::ModelTaskDef>(); | std::shared_ptr<domi::ModelTaskDef> model_task_def = MakeShared<domi::ModelTaskDef>(); | ||||
@@ -1405,14 +1407,14 @@ Status ModelManager::GetModelMemAndWeightSize(const ModelData &model, size_t &me | |||||
} | } | ||||
if (task_partition.size != 0) { | if (task_partition.size != 0) { | ||||
if (!ReadProtoFromArray(task_partition.data, static_cast<int>(task_partition.size), model_task_def.get())) { | if (!ReadProtoFromArray(task_partition.data, static_cast<int>(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; | ModelPartition partition_weight; | ||||
ret = om_file_helper.GetModelPartition(ModelPartitionType::WEIGHTS_DATA, 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); | "Get weight partition failed. ret = %u", ret); | ||||
mem_size = model_task_def->memory_size(); | 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) { | Status ModelManager::GetOrigInputInfo(uint32_t model_id, uint32_t index, OriginInputInfo &orig_input_info) { | ||||
std::shared_ptr<DavinciModel> davinci_model = GetModel(model_id); | std::shared_ptr<DavinciModel> 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); | model_id); | ||||
return davinci_model->GetOrigInputInfo(index, orig_input_info); | return davinci_model->GetOrigInputInfo(index, orig_input_info); | ||||
@@ -1441,7 +1444,7 @@ Status ModelManager::GetAllAippInputOutputDims(uint32_t model_id, uint32_t index | |||||
std::vector<InputOutputDims> &input_dims, | std::vector<InputOutputDims> &input_dims, | ||||
std::vector<InputOutputDims> &output_dims) { | std::vector<InputOutputDims> &output_dims) { | ||||
std::shared_ptr<DavinciModel> davinci_model = GetModel(model_id); | std::shared_ptr<DavinciModel> 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); | "GetAllAippInputOutputDims failed, invalid model_id is %u.", model_id); | ||||
return davinci_model->GetAllAippInputOutputDims(index, input_dims, output_dims); | return davinci_model->GetAllAippInputOutputDims(index, input_dims, output_dims); | ||||
@@ -51,9 +51,9 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY SingleOp::~SingleOp() { | |||||
Status SingleOp::ValidateArgs(const std::vector<DataBuffer> &inputs, const std::vector<DataBuffer> &outputs) { | Status SingleOp::ValidateArgs(const std::vector<DataBuffer> &inputs, const std::vector<DataBuffer> &outputs) { | ||||
auto num_inputs = inputs.size(); | auto num_inputs = inputs.size(); | ||||
if (num_inputs != input_sizes_.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()); | inputs.size()); | ||||
return PARAM_INVALID; | |||||
return ACL_ERROR_GE_PARAM_INVALID; | |||||
} | } | ||||
for (size_t i = 0; i < num_inputs; ++i) { | for (size_t i = 0; i < num_inputs; ++i) { | ||||
@@ -62,16 +62,16 @@ Status SingleOp::ValidateArgs(const std::vector<DataBuffer> &inputs, const std:: | |||||
GELOGI("Input [%zu], aligned_size:%zu, inputs.length:%lu, input_sizes_:%lu", | GELOGI("Input [%zu], aligned_size:%zu, inputs.length:%lu, input_sizes_:%lu", | ||||
i, aligned_size, inputs[i].length, input_sizes_[i]); | i, aligned_size, inputs[i].length, input_sizes_[i]); | ||||
if (aligned_size < 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); | " 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(); | auto num_outputs = outputs.size(); | ||||
if (num_outputs != output_sizes_.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) { | for (size_t i = 0; i < num_outputs; ++i) { | ||||
@@ -80,9 +80,9 @@ Status SingleOp::ValidateArgs(const std::vector<DataBuffer> &inputs, const std:: | |||||
GELOGI("Output [%zu], aligned_size:%zu, outputs.length:%lu, output_sizes_:%lu", | GELOGI("Output [%zu], aligned_size:%zu, outputs.length:%lu, output_sizes_:%lu", | ||||
i, aligned_size, outputs[i].length, output_sizes_[i]); | i, aligned_size, outputs[i].length, output_sizes_[i]); | ||||
if (aligned_size < 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); | "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<DataBuffer> &inputs, const std::ve | |||||
RT_MEMCPY_HOST_TO_DEVICE_EX, | RT_MEMCPY_HOST_TO_DEVICE_EX, | ||||
stream_); | stream_); | ||||
if (rt_ret != RT_ERROR_NONE) { | 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) { | } else if (task->GetOpTaskType() == OP_TASK_AICPUCC) { | ||||
GELOGD("Update aicpu_CC task args"); | GELOGD("Update aicpu_CC task args"); | ||||
@@ -198,29 +198,29 @@ Status DynamicSingleOp::ValidateParams(const vector<GeTensorDesc> &input_desc, | |||||
std::vector<GeTensorDesc> &output_desc, | std::vector<GeTensorDesc> &output_desc, | ||||
std::vector<DataBuffer> &outputs) const { | std::vector<DataBuffer> &outputs) const { | ||||
if (inputs.size() != input_desc.size()) { | 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", | "Input number mismatches input desc number. Input num = %zu, input desc num = %zu", | ||||
inputs.size(), | inputs.size(), | ||||
input_desc.size()); | input_desc.size()); | ||||
return PARAM_INVALID; | |||||
return ACL_ERROR_GE_PARAM_INVALID; | |||||
} | } | ||||
if (outputs.size() != output_desc.size()) { | 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", | "Output number mismatches output desc number. Output num = %zu, output desc num = %zu", | ||||
outputs.size(), | outputs.size(), | ||||
output_desc.size()); | output_desc.size()); | ||||
return PARAM_INVALID; | |||||
return ACL_ERROR_GE_PARAM_INVALID; | |||||
} | } | ||||
if (input_desc.size() != num_inputs_) { | 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_) { | 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; | return SUCCESS; | ||||
@@ -247,8 +247,8 @@ Status DynamicSingleOp::AllocateWorkspaces(const std::vector<int64_t> &workspace | |||||
GE_CHECK_NOTNULL(stream_resource); | GE_CHECK_NOTNULL(stream_resource); | ||||
auto ws_base = stream_resource->MallocMemory(kPurpose, static_cast<size_t>(total_size)); | auto ws_base = stream_resource->MallocMemory(kPurpose, static_cast<size_t>(total_size)); | ||||
if (ws_base == nullptr) { | 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."); | GELOGD("Done allocating workspace memory successfully."); | ||||
@@ -293,10 +293,10 @@ Status DynamicSingleOp::ExecuteAsync(const vector<GeTensorDesc> &input_desc, | |||||
} else if (op_task_->GetOpTaskType() == OP_TASK_AICPU || op_task_->GetOpTaskType() == OP_TASK_AICPUCC) { | } 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_); | return op_task_->LaunchKernel(input_desc, input_buffers, output_desc, output_buffers, stream_); | ||||
} else { | } 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", | "Only TBE_Task, AI_CPU_Task and AI_CPUCC_Task are supported, but got %u", | ||||
op_task_->GetOpTaskType()); | op_task_->GetOpTaskType()); | ||||
return UNSUPPORTED; | |||||
return ACL_ERROR_GE_OP_TASK_TYPE_INVALID; | |||||
} | } | ||||
} | } | ||||
@@ -33,16 +33,16 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status SingleOpManager::GetOpFr | |||||
SingleOp **single_op) { | SingleOp **single_op) { | ||||
GELOGI("GetOpFromModel in. model name = %s", model_name.c_str()); | GELOGI("GetOpFromModel in. model name = %s", model_name.c_str()); | ||||
if (single_op == nullptr) { | 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; | uintptr_t resource_id = 0; | ||||
GE_CHK_STATUS_RET(GetResourceId(stream, resource_id)); | GE_CHK_STATUS_RET(GetResourceId(stream, resource_id)); | ||||
StreamResource *res = GetResource(resource_id, stream); | StreamResource *res = GetResource(resource_id, stream); | ||||
if (res == nullptr) { | 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); | 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)); | GE_CHK_STATUS_RET(GetResourceId(stream, resource_id)); | ||||
StreamResource *res = GetResource(resource_id, stream); | StreamResource *res = GetResource(resource_id, stream); | ||||
if (res == nullptr) { | 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); | 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; | rtContext_t rt_cur_ctx = nullptr; | ||||
auto rt_err = rtCtxGetCurrent(&rt_cur_ctx); | auto rt_err = rtCtxGetCurrent(&rt_cur_ctx); | ||||
if (rt_err != RT_ERROR_NONE) { | if (rt_err != RT_ERROR_NONE) { | ||||
GELOGE(RT_FAILED, "get current context failed, runtime result is %d", static_cast<int>(rt_err)); | |||||
return RT_FAILED; | |||||
GELOGE(rt_err, "get current context failed, runtime result is %d", static_cast<int>(rt_err)); | |||||
return rt_err; | |||||
} | } | ||||
// use current context as resource key instead | // use current context as resource key instead | ||||
GELOGI("use context as resource key instead when default stream"); | GELOGI("use context as resource key instead when default stream"); | ||||
@@ -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); | 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); | model_params_.mem_base = res.MallocMemory(purpose, model_params_.memory_size - model_params_.zero_copy_mem_size); | ||||
if (model_params_.mem_base == nullptr) { | 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); | model_params_.weight_base = res.MallocWeight(purpose, model_params_.weight_size); | ||||
if (model_params_.weight_base == nullptr) { | if (model_params_.weight_base == nullptr) { | ||||
// no need to free memory, for that was handled by StreamResources | // 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(); | auto weight_buffer = model_helper_.GetGeModel()->GetWeight(); | ||||
@@ -121,8 +121,9 @@ Status SingleOpModel::InitModelMem(StreamResource &res) { | |||||
Status SingleOpModel::ParseInputNode(const OpDescPtr &op_desc) { | Status SingleOpModel::ParseInputNode(const OpDescPtr &op_desc) { | ||||
vector<int64_t> offsets = op_desc->GetOutputOffset(); | vector<int64_t> offsets = op_desc->GetOutputOffset(); | ||||
if (offsets.size() != kDataOutputNum) { | 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); | auto output_desc = op_desc->GetOutputDescPtr(0); | ||||
@@ -158,8 +159,8 @@ Status SingleOpModel::LoadAllNodes() { | |||||
Graph graph = ge_model->GetGraph(); | Graph graph = ge_model->GetGraph(); | ||||
auto compute_graph = GraphUtils::GetComputeGraph(graph); | auto compute_graph = GraphUtils::GetComputeGraph(graph); | ||||
if (compute_graph == nullptr) { | 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(); | auto nodes = compute_graph->GetDirectNode(); | ||||
@@ -257,8 +258,8 @@ Status SingleOpModel::BuildTaskList(SingleOp &single_op) { | |||||
} | } | ||||
single_op.tasks_.emplace_back(task); | single_op.tasks_.emplace_back(task); | ||||
} else { | } 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) { | } else if (task_type == RT_MODEL_TASK_KERNEL_EX) { | ||||
GELOGD("Building AICPU_TF task"); | GELOGD("Building AICPU_TF task"); | ||||
@@ -282,7 +283,7 @@ Status SingleOpModel::BuildTaskList(SingleOp &single_op) { | |||||
void SingleOpModel::ParseArgTable(TbeOpTask *task, SingleOp &op) { | void SingleOpModel::ParseArgTable(TbeOpTask *task, SingleOp &op) { | ||||
if (task == nullptr) { | if (task == nullptr) { | ||||
GELOGE(PARAM_INVALID, "tbe op task is nullptr"); | |||||
GELOGE(ACL_ERROR_GE_INTERNAL_ERROR, "tbe op task is nullptr"); | |||||
return; | return; | ||||
} | } | ||||
// args: addr1, addr2, addr3 ... | // args: addr1, addr2, addr3 ... | ||||
@@ -305,14 +306,14 @@ Status SingleOpModel::BuildKernelTask(const domi::KernelDef &kernel_def, TbeOpTa | |||||
const auto &context = kernel_def.context(); | const auto &context = kernel_def.context(); | ||||
auto iter = op_list_.find(context.op_index()); | auto iter = op_list_.find(context.op_index()); | ||||
if (iter == op_list_.end()) { | 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(); | auto *tbe_task = new (std::nothrow) TbeOpTask(); | ||||
if (tbe_task == nullptr) { | 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); | 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) { | bool dynamic_flag, bool& depend_compute_flag, uint64_t session_id) { | ||||
auto iter = op_list_.find(kernel_def.op_index()); | auto iter = op_list_.find(kernel_def.op_index()); | ||||
if (iter == op_list_.end()) { | 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<AiCpuTask> aicpu_task(new (std::nothrow) AiCpuTask()); | std::unique_ptr<AiCpuTask> aicpu_task(new (std::nothrow) AiCpuTask()); | ||||
if (aicpu_task == nullptr) { | 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 builder = AiCpuTaskBuilder(iter->second->GetOpDesc(), kernel_def); | ||||
auto ret = builder.BuildTask(*aicpu_task, model_params_, dynamic_flag, session_id); | 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(); | const auto &context = kernel_def.context(); | ||||
auto iter = op_list_.find(context.op_index()); | auto iter = op_list_.find(context.op_index()); | ||||
if (iter == op_list_.end()) { | 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<AiCpuCCTask> aicpucc_task(new (std::nothrow) AiCpuCCTask()); | std::unique_ptr<AiCpuCCTask> aicpucc_task(new (std::nothrow) AiCpuCCTask()); | ||||
if (aicpucc_task == nullptr) { | 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); | 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)); | GE_CHK_STATUS_RET_NOLOG(BuildCpuKernelTask(task_def.kernel(), &task)); | ||||
single_op.op_task_.reset(task); | single_op.op_task_.reset(task); | ||||
} else { | } 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; | return SUCCESS; | ||||
} | } | ||||
@@ -422,8 +424,8 @@ Status SingleOpModel::BuildTaskListForDynamicOp(DynamicSingleOp &single_op) { | |||||
GE_CHK_STATUS_RET_NOLOG(BuildModelTaskKernel(task_def, single_op)); | GE_CHK_STATUS_RET_NOLOG(BuildModelTaskKernel(task_def, single_op)); | ||||
} else if (task_type == RT_MODEL_TASK_KERNEL_EX) { | } else if (task_type == RT_MODEL_TASK_KERNEL_EX) { | ||||
if (single_op.op_task_ != nullptr) { | 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"); | GELOGD("Building AICPU_TF task"); | ||||
AiCpuTask *aicpu_task = nullptr; | AiCpuTask *aicpu_task = nullptr; | ||||
@@ -434,8 +436,8 @@ Status SingleOpModel::BuildTaskListForDynamicOp(DynamicSingleOp &single_op) { | |||||
depend_compute_flag, dynamic_singleop_sessionid)); | depend_compute_flag, dynamic_singleop_sessionid)); | ||||
if (depend_compute_flag) { | if (depend_compute_flag) { | ||||
if (i >= tasks.size() - 1) { | 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; | ++i; | ||||
const TaskDef ©_task_def = tasks[i]; | const TaskDef ©_task_def = tasks[i]; | ||||
@@ -160,8 +160,8 @@ Status StreamResource::BuildOperator(const string &model_name, const ModelData & | |||||
auto new_op = std::unique_ptr<SingleOp>(new(std::nothrow) SingleOp(&stream_mu_, stream_)); | auto new_op = std::unique_ptr<SingleOp>(new(std::nothrow) SingleOp(&stream_mu_, stream_)); | ||||
if (new_op == nullptr) { | 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()); | GELOGI("To build operator: %s", model_name.c_str()); | ||||
@@ -25,20 +25,20 @@ AiCpuCCTaskBuilder::AiCpuCCTaskBuilder(const OpDescPtr &op_desc, const domi::Ker | |||||
Status AiCpuCCTaskBuilder::SetKernelArgs(AiCpuCCTask &task) { | Status AiCpuCCTaskBuilder::SetKernelArgs(AiCpuCCTask &task) { | ||||
size_t aicpu_arg_size = kernel_def_.args_size(); | size_t aicpu_arg_size = kernel_def_.args_size(); | ||||
if (aicpu_arg_size <= 0) { | 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<uint8_t[]> aicpu_args; | std::unique_ptr<uint8_t[]> aicpu_args; | ||||
aicpu_args.reset(new(std::nothrow) uint8_t[aicpu_arg_size]()); | aicpu_args.reset(new(std::nothrow) uint8_t[aicpu_arg_size]()); | ||||
if (aicpu_args == nullptr) { | 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); | auto err = memcpy_s(aicpu_args.get(), aicpu_arg_size, kernel_def_.args().data(), aicpu_arg_size); | ||||
if (err != EOK) { | 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)); | task.SetIoAddr(aicpu_args.get() + sizeof(aicpu::AicpuParamHead)); | ||||
@@ -30,8 +30,8 @@ namespace ge { | |||||
size_t arg_size = kernel_def_.args_size(); | size_t arg_size = kernel_def_.args_size(); | ||||
auto rt_ret = rtMalloc(io_addr, arg_size, RT_MEMORY_HBM); | auto rt_ret = rtMalloc(io_addr, arg_size, RT_MEMORY_HBM); | ||||
if (rt_ret != RT_ERROR_NONE) { | 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<const void *>(addresses.data()); | const void *src_addr = reinterpret_cast<const void *>(addresses.data()); | ||||
@@ -39,8 +39,8 @@ namespace ge { | |||||
rt_ret = rtMemcpy(*io_addr, arg_size, src_addr, src_len, RT_MEMCPY_HOST_TO_DEVICE); | rt_ret = rtMemcpy(*io_addr, arg_size, src_addr, src_len, RT_MEMCPY_HOST_TO_DEVICE); | ||||
if (rt_ret != RT_ERROR_NONE) { | if (rt_ret != RT_ERROR_NONE) { | ||||
(void)rtFree(*io_addr); | (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; | return SUCCESS; | ||||
@@ -50,8 +50,8 @@ namespace ge { | |||||
auto sec_ret = memcpy_s(&fwk_op_kernel, sizeof(STR_FWK_OP_KERNEL), | auto sec_ret = memcpy_s(&fwk_op_kernel, sizeof(STR_FWK_OP_KERNEL), | ||||
kernel_def_.args().data(), kernel_def_.args().size()); | kernel_def_.args().data(), kernel_def_.args().size()); | ||||
if (sec_ret != EOK) { | 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<uint64_t>(reinterpret_cast<uintptr_t>(io_addr)); | auto io_addr_val = static_cast<uint64_t>(reinterpret_cast<uintptr_t>(io_addr)); | ||||
@@ -65,16 +65,16 @@ namespace ge { | |||||
void *fwk_op_args = nullptr; | void *fwk_op_args = nullptr; | ||||
auto rt_ret = rtMalloc(&fwk_op_args, sizeof(STR_FWK_OP_KERNEL), RT_MEMORY_HBM); | auto rt_ret = rtMalloc(&fwk_op_args, sizeof(STR_FWK_OP_KERNEL), RT_MEMORY_HBM); | ||||
if (rt_ret != RT_ERROR_NONE) { | 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, | rt_ret = rtMemcpy(fwk_op_args, sizeof(STR_FWK_OP_KERNEL), &fwk_op_kernel, | ||||
sizeof(STR_FWK_OP_KERNEL), RT_MEMCPY_HOST_TO_DEVICE); | sizeof(STR_FWK_OP_KERNEL), RT_MEMCPY_HOST_TO_DEVICE); | ||||
if (rt_ret != RT_ERROR_NONE) { | if (rt_ret != RT_ERROR_NONE) { | ||||
(void)rtFree(fwk_op_args); | (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; | *args = fwk_op_args; | ||||
return SUCCESS; | return SUCCESS; | ||||
@@ -83,9 +83,9 @@ namespace ge { | |||||
Status AiCpuTaskBuilder::InitWorkspaceAndIO(void **io_addr, void **kernel_workspace, | Status AiCpuTaskBuilder::InitWorkspaceAndIO(void **io_addr, void **kernel_workspace, | ||||
const SingleOpModelParam ¶m, bool dynamic_flag) { | const SingleOpModelParam ¶m, bool dynamic_flag) { | ||||
if (kernel_def_.args_size() > sizeof(STR_FWK_OP_KERNEL)) { | 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()); | 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 addresses = BuildTaskUtils::GetAddresses(op_desc_, param); | ||||
auto ws_addr_vec = addresses.at(BuildTaskUtils::kAddressIndexWorkspace); | 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)); | GE_CHK_RT_RET(rtMalloc(kernel_workspace, kernel_def_.task_info_size(), RT_MEMORY_HBM)); | ||||
} else { | } else { | ||||
if (ws_addr_vec.empty()) { | 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]; | *kernel_workspace = ws_addr_vec[0]; | ||||
} | } | ||||
@@ -143,8 +143,8 @@ namespace ge { | |||||
GELOGI("Begin to CreateAicpuSession, session id: %lu", session_id); | GELOGI("Begin to CreateAicpuSession, session id: %lu", session_id); | ||||
GE_CHECK_NOTNULL(ModelManager::GetInstance()); | GE_CHECK_NOTNULL(ModelManager::GetInstance()); | ||||
GE_IF_BOOL_EXEC(ModelManager::GetInstance()->CreateAicpuSession(session_id) != SUCCESS, | 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); | ret = SetKernelArgs(&task.args_, fwk_op_kernel); | ||||
if (ret != SUCCESS) { | if (ret != SUCCESS) { | ||||
return ret; | return ret; | ||||
@@ -693,8 +693,8 @@ Status AiCpuCCTask::LaunchKernel(rtStream_t stream) { | |||||
block_dim_, args_.get(), static_cast<uint32_t>(arg_size_), | block_dim_, args_.get(), static_cast<uint32_t>(arg_size_), | ||||
sm_desc, stream, dump_flag_); | sm_desc, stream, dump_flag_); | ||||
if (ret != RT_ERROR_NONE) { | 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"); | GELOGD("Invoke rtCpuKernelLaunch succeeded"); | ||||
@@ -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; | binary.magic = param.core_type == 0 ? RT_DEV_BINARY_MAGIC_ELF : RT_DEV_BINARY_MAGIC_ELF_AIVEC; | ||||
auto ret = rtDevBinaryRegister(&binary, bin_handle); | auto ret = rtDevBinaryRegister(&binary, bin_handle); | ||||
if (ret != RT_ERROR_NONE) { | 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<int>(ret)); | param.core_type, static_cast<int>(ret)); | ||||
return RT_FAILED; | |||||
return ret; | |||||
} | } | ||||
return SUCCESS; | return SUCCESS; | ||||
@@ -106,9 +106,9 @@ Status TbeTaskBuilder::DoRegisterMeta(void *bin_handle) { | |||||
if (!meta_data.empty()) { | if (!meta_data.empty()) { | ||||
auto rt_ret = rtMetadataRegister(bin_handle, meta_data.c_str()); | auto rt_ret = rtMetadataRegister(bin_handle, meta_data.c_str()); | ||||
if (rt_ret != RT_ERROR_NONE) { | 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<int>(rt_ret)); | meta_data.c_str(), static_cast<int>(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) { | 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); | auto rt_ret = rtFunctionRegister(bin_handle, stub_name, stub_name, kernel_name, FUNC_MODE_NORMAL); | ||||
if (rt_ret != RT_ERROR_NONE) { | 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<int>(rt_ret)); | static_cast<int>(rt_ret)); | ||||
return RT_FAILED; | |||||
return rt_ret; | |||||
} | } | ||||
return SUCCESS; | return SUCCESS; | ||||
@@ -173,14 +173,14 @@ Status TbeTaskBuilder::RegisterKernel(TbeOpTask &task, const SingleOpModelParam | |||||
auto tbe_kernel = GetTbeKernel(op_desc_); | auto tbe_kernel = GetTbeKernel(op_desc_); | ||||
if (tbe_kernel == nullptr) { | 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<KernelHolder>(new (std::nothrow) KernelHolder(stub_func, tbe_kernel)); | auto holder = std::unique_ptr<KernelHolder>(new (std::nothrow) KernelHolder(stub_func, tbe_kernel)); | ||||
if (holder == nullptr) { | 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; | void *bin_handle = nullptr; | ||||
@@ -189,8 +189,8 @@ Status TbeTaskBuilder::RegisterKernel(TbeOpTask &task, const SingleOpModelParam | |||||
holder->SetBinHandle(bin_handle); | holder->SetBinHandle(bin_handle); | ||||
if (!registry.AddKernel(stub_name_, std::move(holder))) { | if (!registry.AddKernel(stub_name_, std::move(holder))) { | ||||
// should not happen. only one thread can reach here | // 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); | auto rtRet = rtMemAllocManaged(sm_desc, sm_desc_str.size(), RT_MEMORY_SPM); | ||||
if (rtRet != RT_ERROR_NONE) { | if (rtRet != RT_ERROR_NONE) { | ||||
GELOGE(RT_FAILED, "rtMemAllocManaged failed, ret: %d", static_cast<int>(rtRet)); | |||||
return RT_FAILED; | |||||
GELOGE(rtRet, "rtMemAllocManaged failed, ret: %d", static_cast<int>(rtRet)); | |||||
return rtRet; | |||||
} | } | ||||
rtRet = rtMemcpy(*sm_desc, sm_desc_str.size(), sm_desc_str.data(), sm_desc_str.size(), RT_MEMCPY_HOST_TO_DEVICE); | 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) { | if (rtRet != RT_ERROR_NONE) { | ||||
(void)rtMemFreeManaged(*sm_desc); | (void)rtMemFreeManaged(*sm_desc); | ||||
GELOGE(RT_FAILED, "rtMemcpy, ret: %d", static_cast<int>(rtRet)); | |||||
return RT_FAILED; | |||||
GELOGE(rtRet, "rtMemcpy, ret: %d", static_cast<int>(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); | auto rtRet = rtMemcpy(args.get(), arg_size, kernel_def_.args().data(), arg_size, RT_MEMCPY_HOST_TO_HOST); | ||||
if (rtRet != RT_ERROR_NONE) { | if (rtRet != RT_ERROR_NONE) { | ||||
GELOGE(RT_FAILED, "rtMemcpy args failed, size = %zu, ret = %d", arg_size, static_cast<int>(rtRet)); | |||||
return RT_FAILED; | |||||
GELOGE(rtRet, "rtMemcpy args failed, size = %zu, ret = %d", arg_size, static_cast<int>(rtRet)); | |||||
return rtRet; | |||||
} | } | ||||
const domi::KernelContext &context = kernel_def_.context(); | 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(); | 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); | rtRet = rtMemcpy(args.get() + offset, arg_size - offset, src_addr, src_len, RT_MEMCPY_HOST_TO_HOST); | ||||
if (rtRet != RT_ERROR_NONE) { | if (rtRet != RT_ERROR_NONE) { | ||||
GELOGE(RT_FAILED, "rtMemcpy addresses failed, ret = %d", static_cast<int>(rtRet)); | |||||
return RT_FAILED; | |||||
GELOGE(rtRet, "rtMemcpy addresses failed, ret = %d", static_cast<int>(rtRet)); | |||||
return rtRet; | |||||
} | } | ||||
} | } | ||||
@@ -285,8 +285,8 @@ Status TbeTaskBuilder::BuildTask(TbeOpTask &task, const SingleOpModelParam ¶ | |||||
void *stub_func = nullptr; | void *stub_func = nullptr; | ||||
auto rtRet = rtGetFunctionByName(stub_name_.c_str(), &stub_func); | auto rtRet = rtGetFunctionByName(stub_name_.c_str(), &stub_func); | ||||
if (rtRet != SUCCESS) { | if (rtRet != SUCCESS) { | ||||
GELOGE(RT_FAILED, "rtGetFunctionByName failed."); | |||||
return RT_FAILED; | |||||
GELOGE(rtRet, "rtGetFunctionByName failed."); | |||||
return rtRet; | |||||
} | } | ||||
task.SetStubFunc(stub_name_, stub_func); | task.SetStubFunc(stub_name_, stub_func); | ||||
@@ -299,8 +299,8 @@ Status TbeTaskBuilder::InitTilingInfo(TbeOpTask &task) { | |||||
(void)AttrUtils::GetInt(op_desc_, kAttrOpParamSize, max_size); | (void)AttrUtils::GetInt(op_desc_, kAttrOpParamSize, max_size); | ||||
GELOGD("Got op param size by key: %s, ret = %ld", kAttrOpParamSize, max_size); | GELOGD("Got op param size by key: %s, ret = %ld", kAttrOpParamSize, max_size); | ||||
if (max_size <= 0) { | 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; | void *tiling_buffer = nullptr; | ||||
@@ -19,6 +19,7 @@ | |||||
#include <map> | #include <map> | ||||
#include <string> | #include <string> | ||||
#include "ge_error_codes.h" | |||||
namespace ge { | namespace ge { | ||||
class StatusFactory { | class StatusFactory { | ||||
@@ -66,11 +67,47 @@ class ErrorNoRegisterar { | |||||
((0xFF & (static_cast<uint8_t>(modid))) << 12) | (0x0FFF & (static_cast<uint16_t>(value))); \ | ((0xFF & (static_cast<uint8_t>(modid))) << 12) | (0x0FFF & (static_cast<uint16_t>(value))); \ | ||||
const ErrorNoRegisterar g_##name##_errorno(name, desc); | const ErrorNoRegisterar g_##name##_errorno(name, desc); | ||||
#define GE_ERRORNO_EXTERNAL(name, desc) const ErrorNoRegisterar g_##name##_errorno(name, desc); | |||||
using Status = uint32_t; | using Status = uint32_t; | ||||
// General error code | // General error code | ||||
GE_ERRORNO(0, 0, 0, 0, 0, SUCCESS, 0, "success"); | GE_ERRORNO(0, 0, 0, 0, 0, SUCCESS, 0, "success"); | ||||
GE_ERRORNO(0b11, 0b11, 0b111, 0xFF, 0b11111, FAILED, 0xFFF, "failed"); /*lint !e401*/ | 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 | } // namespace ge | ||||
#endif // INC_EXTERNAL_GE_GE_API_ERROR_CODES_H_ | #endif // INC_EXTERNAL_GE_GE_API_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 <stddef.h> | |||||
#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_ |
@@ -1 +1 @@ | |||||
Subproject commit be949d5ff32baec332aa8765d2b211334ae84dbf | |||||
Subproject commit ba04e25e878af2ac5f9a697806daee0768ae3bad |
@@ -1 +1 @@ | |||||
Subproject commit d865fa6e67c00c536e6df2f86d4912c1f1feff4c | |||||
Subproject commit 308e3587ec54fdd32ed7113d64a1335208701f59 |