|
@@ -125,34 +125,41 @@ void SetDynamicInputDataFlag(const ge::RunModelData &input_data, const std::vect |
|
|
|
|
|
|
|
|
bool IsDynamicBatchSizeMatchModel(uint64_t batch_size, const vector<std::vector<int64_t>> &batch_info) { |
|
|
bool IsDynamicBatchSizeMatchModel(uint64_t batch_size, const vector<std::vector<int64_t>> &batch_info) { |
|
|
if (batch_info.empty()) { |
|
|
if (batch_info.empty()) { |
|
|
GELOGE(ge::FAILED, "Dynamic batch info is empty."); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "param Dynamic batch info is empty, check invalid."); |
|
|
|
|
|
GELOGE(ge::FAILED, "[Check][Param] Dynamic batch info is empty."); |
|
|
return false; |
|
|
return false; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
for (auto batch : batch_info) { |
|
|
for (auto batch : batch_info) { |
|
|
if (batch.size() != kDynamicBatchSizeVecSize) { |
|
|
if (batch.size() != kDynamicBatchSizeVecSize) { |
|
|
GELOGE(ge::FAILED, "Dynamic batch param num is %zu, current batch size is %zu.", kDynamicBatchSizeVecSize, |
|
|
|
|
|
batch.size()); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "Dynamic batch param num is %zu, current batch size is %zu.", |
|
|
|
|
|
kDynamicBatchSizeVecSize, batch.size()); |
|
|
|
|
|
GELOGE(ge::FAILED, "[Check][Param] Dynamic batch param num is %zu, current batch size is %zu.", |
|
|
|
|
|
kDynamicBatchSizeVecSize, batch.size()); |
|
|
return false; |
|
|
return false; |
|
|
} |
|
|
} |
|
|
if (batch[0] == static_cast<int64_t>(batch_size)) { |
|
|
if (batch[0] == static_cast<int64_t>(batch_size)) { |
|
|
return true; |
|
|
return true; |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
GELOGE(ge::FAILED, "Dynamic batch %lu can not match the gear of model.", batch_size); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "Dynamic batch %lu can not match the gear of model.", batch_size); |
|
|
|
|
|
GELOGE(ge::FAILED, "[Check][Param] Dynamic batch %lu can not match the gear of model.", batch_size); |
|
|
return false; |
|
|
return false; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
bool IsDynamicImageSizeMatchModel(uint64_t image_height, uint64_t image_width, |
|
|
bool IsDynamicImageSizeMatchModel(uint64_t image_height, uint64_t image_width, |
|
|
const vector<std::vector<int64_t>> &batch_info) { |
|
|
const vector<std::vector<int64_t>> &batch_info) { |
|
|
if (batch_info.empty()) { |
|
|
if (batch_info.empty()) { |
|
|
GELOGE(ge::FAILED, "Dynamic batch info is empty."); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "ParamDynamic batch info is empty. check invalid"); |
|
|
|
|
|
GELOGE(ge::FAILED, "[Check][Param] Dynamic batch info is empty."); |
|
|
return false; |
|
|
return false; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
for (auto resolution : batch_info) { |
|
|
for (auto resolution : batch_info) { |
|
|
if (resolution.size() != kDynamicImageSizeVecSize) { |
|
|
if (resolution.size() != kDynamicImageSizeVecSize) { |
|
|
GELOGE(ge::FAILED, "Dynamic resolution param num is %zu, current resolution size is %zu.", |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "Dynamic resolution param num is %zu, current resolution size is %zu.", |
|
|
|
|
|
kDynamicImageSizeVecSize, resolution.size()); |
|
|
|
|
|
GELOGE(ge::FAILED, "[Check][Param] Dynamic resolution param num is %zu, current resolution size is %zu.", |
|
|
kDynamicImageSizeVecSize, resolution.size()); |
|
|
kDynamicImageSizeVecSize, resolution.size()); |
|
|
return false; |
|
|
return false; |
|
|
} |
|
|
} |
|
@@ -160,22 +167,28 @@ bool IsDynamicImageSizeMatchModel(uint64_t image_height, uint64_t image_width, |
|
|
return true; |
|
|
return true; |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
GELOGE(ge::FAILED, "Dynamic resolution (%lu,%lu) can not match the gear of model.", image_height, image_width); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "Dynamic resolution (%lu,%lu) can not match the gear of model.", |
|
|
|
|
|
image_height, image_width); |
|
|
|
|
|
GELOGE(ge::FAILED, "[Check][Param]Dynamic resolution (%lu,%lu) can not match the gear of model.", |
|
|
|
|
|
image_height, image_width); |
|
|
return false; |
|
|
return false; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
bool IsDynmaicDimsSizeMatchModel(const vector<uint64_t> cur_dynamic_dims, |
|
|
bool IsDynmaicDimsSizeMatchModel(const vector<uint64_t> cur_dynamic_dims, |
|
|
const vector<vector<int64_t>> &batch_info) { |
|
|
const vector<vector<int64_t>> &batch_info) { |
|
|
if (batch_info.empty()) { |
|
|
if (batch_info.empty()) { |
|
|
GELOGE(ACL_ERROR_GE_PARAM_INVALID, "Dynamic batch info is empty."); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "param batch_info is empty, check invalid"); |
|
|
|
|
|
GELOGE(ACL_ERROR_GE_PARAM_INVALID, "[Check][Param] Dynamic batch info is empty."); |
|
|
return false; |
|
|
return false; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
bool find_match = false; |
|
|
bool find_match = false; |
|
|
for (auto resolution : batch_info) { |
|
|
for (auto resolution : batch_info) { |
|
|
if (cur_dynamic_dims.size() != resolution.size()) { |
|
|
if (cur_dynamic_dims.size() != resolution.size()) { |
|
|
GELOGE(ACL_ERROR_GE_PARAM_INVALID, "Cur dynamic dims param num is %zu, current resolution size is %zu.", |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "Cur dynamic dims param num is %zu, current resolution size is %zu.", |
|
|
|
|
|
cur_dynamic_dims.size(), resolution.size()); |
|
|
|
|
|
GELOGE(ACL_ERROR_GE_PARAM_INVALID, |
|
|
|
|
|
"[Check][Param] Cur dynamic dims param num is %zu, current resolution size is %zu.", |
|
|
cur_dynamic_dims.size(), resolution.size()); |
|
|
cur_dynamic_dims.size(), resolution.size()); |
|
|
return false; |
|
|
return false; |
|
|
} |
|
|
} |
|
@@ -192,7 +205,7 @@ bool IsDynmaicDimsSizeMatchModel(const vector<uint64_t> cur_dynamic_dims, |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
if (!find_match) { |
|
|
if (!find_match) { |
|
|
GELOGE(ACL_ERROR_GE_PARAM_INVALID, "choose dynamic dims can not match the gear of model."); |
|
|
|
|
|
|
|
|
GELOGE(ACL_ERROR_GE_PARAM_INVALID, "[Check][Param] choose dynamic dims can not match the gear of model."); |
|
|
} |
|
|
} |
|
|
return find_match; |
|
|
return find_match; |
|
|
} |
|
|
} |
|
@@ -241,7 +254,7 @@ Status GeExecutor::Initialize() { |
|
|
|
|
|
|
|
|
Status init_hostcpu_engine_status = HostCpuEngine::GetInstance().Initialize(); |
|
|
Status init_hostcpu_engine_status = HostCpuEngine::GetInstance().Initialize(); |
|
|
if (init_hostcpu_engine_status != SUCCESS) { |
|
|
if (init_hostcpu_engine_status != SUCCESS) { |
|
|
GELOGE(init_hostcpu_engine_status, "Failed to initialize HostCpuEngine"); |
|
|
|
|
|
|
|
|
GELOGE(init_hostcpu_engine_status, "[initialize][HostCpuEngine] failed"); |
|
|
return init_hostcpu_engine_status; |
|
|
return init_hostcpu_engine_status; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
@@ -251,12 +264,12 @@ Status GeExecutor::Initialize() { |
|
|
mem_type.push_back(RT_MEMORY_P2P_DDR); |
|
|
mem_type.push_back(RT_MEMORY_P2P_DDR); |
|
|
auto ret = MemManager::Instance().Initialize(mem_type); |
|
|
auto ret = MemManager::Instance().Initialize(mem_type); |
|
|
if (ret != SUCCESS) { |
|
|
if (ret != SUCCESS) { |
|
|
GELOGE(ret, "Memory Manager init failed."); |
|
|
|
|
|
|
|
|
GELOGE(ret, "[Initialize][MemManager] failed."); |
|
|
return ret; |
|
|
return ret; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
GE_CHK_STATUS_RET(OpsKernelBuilderManager::Instance().Initialize({}, false), |
|
|
GE_CHK_STATUS_RET(OpsKernelBuilderManager::Instance().Initialize({}, false), |
|
|
"Failed to initialize OpsKernelBuilders."); |
|
|
|
|
|
|
|
|
"[Initialize][OpsKernelBuilderManager] failed."); |
|
|
|
|
|
|
|
|
// Start profiling |
|
|
// Start profiling |
|
|
Options profiling_options; |
|
|
Options profiling_options; |
|
@@ -292,13 +305,18 @@ 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(ACL_ERROR_GE_DYNAMIC_INPUT_ADDR_INVALID, "Dynamic input addr is nullptr!"); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "param dynamic_input_addr is nullptr, check invalid, model id:%u", model_id); |
|
|
|
|
|
GELOGE(ACL_ERROR_GE_DYNAMIC_INPUT_ADDR_INVALID, |
|
|
|
|
|
"[Check][Param] Dynamic input addr is nullptr, model id:%u", model_id); |
|
|
return ACL_ERROR_GE_DYNAMIC_INPUT_ADDR_INVALID; |
|
|
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(ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID, "Dynamic input size [%lu] is less than [%lu]!", length, size); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "Dynamic input size [%lu] is less than [%lu], check invalid, model id:%u", |
|
|
|
|
|
length, size, model_id); |
|
|
|
|
|
GELOGE(ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID, |
|
|
|
|
|
"[Check][Param] Dynamic input size [%lu] is less than [%lu], model id:%u", length, size, model_id); |
|
|
return ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID; |
|
|
return ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID; |
|
|
} |
|
|
} |
|
|
if (length >= sizeof(uint64_t)) { |
|
|
if (length >= sizeof(uint64_t)) { |
|
@@ -311,24 +329,28 @@ Status GeExecutor::SetDynamicBatchSize(uint32_t model_id, void *dynamic_input_ad |
|
|
int32_t dynamic_type = static_cast<int32_t>(FIXED); |
|
|
int32_t dynamic_type = static_cast<int32_t>(FIXED); |
|
|
Status ret = GraphExecutor::GetDynamicBatchInfo(model_id, batch_info, dynamic_type); |
|
|
Status ret = GraphExecutor::GetDynamicBatchInfo(model_id, batch_info, dynamic_type); |
|
|
if (ret != SUCCESS) { |
|
|
if (ret != SUCCESS) { |
|
|
GELOGE(ret, "Get dynamic input info failed."); |
|
|
|
|
|
|
|
|
REPORT_CALL_ERROR("E19999", "get dynamic batch info failed, model id:%u", model_id); |
|
|
|
|
|
GELOGE(ret, "[Get][DynamicBatchInfo] failed, model id:%u.", model_id); |
|
|
return ret; |
|
|
return ret; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
if (!IsDynamicBatchSizeMatchModel(batch_size, batch_info)) { |
|
|
if (!IsDynamicBatchSizeMatchModel(batch_size, batch_info)) { |
|
|
GELOGE(ACL_ERROR_GE_DYNAMIC_BATCH_SIZE_INVALID, "The current dynamic input does not match the gear of the model."); |
|
|
|
|
|
|
|
|
GELOGE(ACL_ERROR_GE_DYNAMIC_BATCH_SIZE_INVALID, |
|
|
|
|
|
"[Check][Param] The current dynamic input does not match the gear of the model(id:%u).", model_id); |
|
|
return ACL_ERROR_GE_DYNAMIC_BATCH_SIZE_INVALID; |
|
|
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)); |
|
|
if (ret != SUCCESS) { |
|
|
if (ret != SUCCESS) { |
|
|
GELOGE(ret, "Set dynamic size failed"); |
|
|
|
|
|
|
|
|
REPORT_CALL_ERROR("E19999", "set dynamic size failed, model id:%u, dynamic_type:1", model_id); |
|
|
|
|
|
GELOGE(ret, "[Set][DynamicSize] failed, model id:%u, dynamic_type:1", model_id); |
|
|
return ret; |
|
|
return ret; |
|
|
} |
|
|
} |
|
|
// 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_ret, "memcpy dynamic batch input data failed! ret: 0x%X", rt_ret); |
|
|
|
|
|
|
|
|
REPORT_CALL_ERROR("E19999", "Call rtMemcpy, size:%lu ret:0x%X", length, rt_ret); |
|
|
|
|
|
GELOGE(rt_ret, "[Call][RtMemcpy] memcpy dynamic batch input data failed! size:%lu ret:0x%X", length, rt_ret); |
|
|
return RT_ERROR_TO_GE_STATUS(rt_ret); |
|
|
return RT_ERROR_TO_GE_STATUS(rt_ret); |
|
|
} |
|
|
} |
|
|
return SUCCESS; |
|
|
return SUCCESS; |
|
@@ -337,14 +359,19 @@ 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(ACL_ERROR_GE_DYNAMIC_INPUT_ADDR_INVALID, "Dynamic input addr is nullptr!"); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "param dynamic_input_addr is nullptr, check invalid, model id:%u", model_id); |
|
|
|
|
|
GELOGE(ACL_ERROR_GE_DYNAMIC_INPUT_ADDR_INVALID, |
|
|
|
|
|
"[Check][Param] Dynamic input addr is nullptr, model id:%u", model_id); |
|
|
return ACL_ERROR_GE_DYNAMIC_INPUT_ADDR_INVALID; |
|
|
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) { |
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "Dynamic input size [%lu] is less than [%lu], check invalid, model id:%u", |
|
|
|
|
|
length, dynamic_input_size, model_id); |
|
|
GELOGE(ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID, |
|
|
GELOGE(ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID, |
|
|
"Dynamic input size [%lu] is less than [%lu]!", length, dynamic_input_size); |
|
|
|
|
|
|
|
|
"[Check][Param] Dynamic input size [%lu] is less than [%lu], model id:%u", |
|
|
|
|
|
length, dynamic_input_size, model_id); |
|
|
return ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID; |
|
|
return ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID; |
|
|
} |
|
|
} |
|
|
uint64_t size = sizeof(uint32_t); |
|
|
uint64_t size = sizeof(uint32_t); |
|
@@ -357,18 +384,22 @@ Status GeExecutor::SetDynamicImageSize(uint32_t model_id, void *dynamic_input_ad |
|
|
int32_t dynamic_type = static_cast<int32_t>(FIXED); |
|
|
int32_t dynamic_type = static_cast<int32_t>(FIXED); |
|
|
Status ret = GraphExecutor::GetDynamicBatchInfo(model_id, batch_info, dynamic_type); |
|
|
Status ret = GraphExecutor::GetDynamicBatchInfo(model_id, batch_info, dynamic_type); |
|
|
if (ret != SUCCESS) { |
|
|
if (ret != SUCCESS) { |
|
|
GELOGE(ret, "Get dynamic input info failed."); |
|
|
|
|
|
|
|
|
REPORT_CALL_ERROR("E19999", "Get dynamic input info failed, model id:%u.", model_id); |
|
|
|
|
|
GELOGE(ret, "[Get][DynamicBatchInfo] failed, model id:%u.", model_id); |
|
|
return ret; |
|
|
return ret; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
if (!IsDynamicImageSizeMatchModel(image_height, image_width, batch_info)) { |
|
|
if (!IsDynamicImageSizeMatchModel(image_height, image_width, batch_info)) { |
|
|
GELOGE(ACL_ERROR_GE_DYNAMIC_BATCH_SIZE_INVALID, "The current dynamic input does not match the gear of the model."); |
|
|
|
|
|
|
|
|
GELOGE(ACL_ERROR_GE_DYNAMIC_BATCH_SIZE_INVALID, |
|
|
|
|
|
"[Check][Param] The current dynamic input does not match the gear of the model, " |
|
|
|
|
|
"image_height:%lu, image_width:%lu.", image_height, image_width); |
|
|
return ACL_ERROR_GE_DYNAMIC_BATCH_SIZE_INVALID; |
|
|
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)); |
|
|
if (ret != SUCCESS) { |
|
|
if (ret != SUCCESS) { |
|
|
GELOGE(ret, "Set dynamic size failed"); |
|
|
|
|
|
|
|
|
REPORT_CALL_ERROR("E19999", "Set dynamic size failed, model id:%u,", model_id); |
|
|
|
|
|
GELOGE(ret, "[Set][DynamicSize] failed, model id:%u", model_id); |
|
|
return ret; |
|
|
return ret; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
@@ -376,7 +407,9 @@ Status GeExecutor::SetDynamicImageSize(uint32_t model_id, void *dynamic_input_ad |
|
|
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_ret, "memcpy dynamic resolution input data failed! ret: 0x%X", rt_ret); |
|
|
|
|
|
|
|
|
REPORT_CALL_ERROR("E19999", "Call rtMemcpy failed! size:%lu, ret:0x%X, model id:%u", size, rt_ret, model_id); |
|
|
|
|
|
GELOGE(rt_ret, "[Call][RtMemcpy] memcpy dynamic resolution input data failed! size:%lu, ret:0x%X, model id:%u", |
|
|
|
|
|
size, rt_ret, model_id); |
|
|
return RT_ERROR_TO_GE_STATUS(rt_ret); |
|
|
return RT_ERROR_TO_GE_STATUS(rt_ret); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
@@ -385,7 +418,10 @@ Status GeExecutor::SetDynamicImageSize(uint32_t model_id, void *dynamic_input_ad |
|
|
rt_ret = rtMemcpy(reinterpret_cast<void *>(reinterpret_cast<uint8_t *>(dynamic_input_addr) + size), |
|
|
rt_ret = rtMemcpy(reinterpret_cast<void *>(reinterpret_cast<uint8_t *>(dynamic_input_addr) + size), |
|
|
remain_size, &image_width, size, RT_MEMCPY_HOST_TO_DEVICE); |
|
|
remain_size, &image_width, size, RT_MEMCPY_HOST_TO_DEVICE); |
|
|
if (rt_ret != RT_ERROR_NONE) { |
|
|
if (rt_ret != RT_ERROR_NONE) { |
|
|
GELOGE(rt_ret, "memcpy dynamic resolution input data failed!"); |
|
|
|
|
|
|
|
|
REPORT_CALL_ERROR("E19999", "Call rtMemcpy failed! size:%lu, ret:0x%X, model id:%u", |
|
|
|
|
|
remain_size, rt_ret, model_id); |
|
|
|
|
|
GELOGE(rt_ret, "[Call][RtMemcpy] memcpy dynamic resolution input data failed! size:%lu, ret:0x%X, model id:%u", |
|
|
|
|
|
remain_size, rt_ret, model_id); |
|
|
return RT_ERROR_TO_GE_STATUS(rt_ret); |
|
|
return RT_ERROR_TO_GE_STATUS(rt_ret); |
|
|
} |
|
|
} |
|
|
return SUCCESS; |
|
|
return SUCCESS; |
|
@@ -394,40 +430,48 @@ 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(ACL_ERROR_GE_DYNAMIC_INPUT_ADDR_INVALID, "Dynamic input addr is nullptr!"); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "Param dynamic_input_addr is nullptr, check invalid, model id:%u", model_id); |
|
|
|
|
|
GELOGE(ACL_ERROR_GE_DYNAMIC_INPUT_ADDR_INVALID, |
|
|
|
|
|
"[Check][Param] Dynamic input addr is nullptr, model id:%u", model_id); |
|
|
return ACL_ERROR_GE_DYNAMIC_INPUT_ADDR_INVALID; |
|
|
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(ret, "Set cur gear dynamic dims failed"); |
|
|
|
|
|
|
|
|
GELOGE(ret, "[Get][CurDynamicDims] failed, model id:%u", model_id); |
|
|
return ret; |
|
|
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); |
|
|
ret = GraphExecutor::GetDynamicBatchInfo(model_id, batch_info, dynamic_type); |
|
|
ret = GraphExecutor::GetDynamicBatchInfo(model_id, batch_info, dynamic_type); |
|
|
if (ret != SUCCESS) { |
|
|
if (ret != SUCCESS) { |
|
|
GELOGE(ret, "Get dynamic input info failed."); |
|
|
|
|
|
|
|
|
REPORT_CALL_ERROR("E19999", "Get dynamic input info failed, model id:%u.", model_id); |
|
|
|
|
|
GELOGE(ret, "[Get][DynamicBatchInfo] failed, model id:%u.", model_id); |
|
|
return ret; |
|
|
return ret; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
if (!IsDynmaicDimsSizeMatchModel(cur_dynamic_dims, batch_info)) { |
|
|
if (!IsDynmaicDimsSizeMatchModel(cur_dynamic_dims, batch_info)) { |
|
|
GELOGE(ACL_ERROR_GE_DYNAMIC_BATCH_SIZE_INVALID, "The current dynamic input does not match the gear of the model."); |
|
|
|
|
|
|
|
|
GELOGE(ACL_ERROR_GE_DYNAMIC_BATCH_SIZE_INVALID, |
|
|
|
|
|
"[Check][Param] The current dynamic input does not match the gear of the model, id:%u.", model_id); |
|
|
return ACL_ERROR_GE_DYNAMIC_BATCH_SIZE_INVALID; |
|
|
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(ret, "Set dynamic size failed"); |
|
|
|
|
|
|
|
|
REPORT_CALL_ERROR("E19999", "Set dynamic size failed, model id:%u", model_id); |
|
|
|
|
|
GELOGE(ret, "[Set][DynamicSize] failed, model id:%u", model_id); |
|
|
return ret; |
|
|
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) { |
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "input dynamic size [%lu] is less than [%lu], model id:%u", |
|
|
|
|
|
length, dynamic_input_size, model_id); |
|
|
GELOGE(ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID, |
|
|
GELOGE(ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID, |
|
|
"Dynamic input size [%lu] is less than [%lu]!", length, dynamic_input_size); |
|
|
|
|
|
|
|
|
"[Check][Param] Dynamic input size [%lu] is less than [%lu], model id:%u", |
|
|
|
|
|
length, dynamic_input_size, model_id); |
|
|
return ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID; |
|
|
return ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID; |
|
|
} |
|
|
} |
|
|
uint64_t size = sizeof(uint32_t); |
|
|
uint64_t size = sizeof(uint32_t); |
|
@@ -440,7 +484,9 @@ Status GeExecutor::SetDynamicDims(uint32_t model_id, void *dynamic_input_addr, u |
|
|
rt_ret = rtMemcpy(reinterpret_cast<void *>(reinterpret_cast<uint8_t *>(dynamic_input_addr) + size * i), |
|
|
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); |
|
|
length - size * i, &cur_dynamic_dims[i], size, RT_MEMCPY_HOST_TO_DEVICE); |
|
|
if (rt_ret != RT_ERROR_NONE) { |
|
|
if (rt_ret != RT_ERROR_NONE) { |
|
|
GELOGE(rt_ret, "memcpy dynamic resolution input data failed!"); |
|
|
|
|
|
|
|
|
REPORT_CALL_ERROR("E19999", "Call rtMemcpy failed, size:%lu, ret:0x%X", (length - size * i), rt_ret); |
|
|
|
|
|
GELOGE(rt_ret, "[Call][RtMemcpy] memcpy dynamic resolution input data failed! size:%lu, ret:0x%X", |
|
|
|
|
|
length - size * i, rt_ret); |
|
|
return RT_ERROR_TO_GE_STATUS(rt_ret); |
|
|
return RT_ERROR_TO_GE_STATUS(rt_ret); |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
@@ -454,14 +500,14 @@ 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(ret, "GetModelDescInfo failed."); |
|
|
|
|
|
|
|
|
GELOGE(ret, "[Get][ModelDescInfo] failed, model id:%u.", model_id); |
|
|
return ret; |
|
|
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(ret, "GetUserDesignateShapeOrder failed."); |
|
|
|
|
|
|
|
|
GELOGE(ret, "[Call][GetUserDesignateShapeOrder] failed, model id:%u.", model_id); |
|
|
return ret; |
|
|
return ret; |
|
|
} |
|
|
} |
|
|
for (auto &data_name : user_designate_shape_order) { |
|
|
for (auto &data_name : user_designate_shape_order) { |
|
@@ -475,8 +521,10 @@ 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()){ |
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "Dynamic input size [%lu] is not equal with all data dims size [%lu]!", |
|
|
|
|
|
dynamic_dims.size(), all_data_dims.size()); |
|
|
GELOGE(ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID, |
|
|
GELOGE(ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID, |
|
|
"Dynamic input size [%lu] is not equal with all data dims size [%lu]!", |
|
|
|
|
|
|
|
|
"[Check][Param] 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 ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID; |
|
|
return ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID; |
|
|
} |
|
|
} |
|
@@ -484,8 +532,10 @@ Status GeExecutor::GetCurDynamicDims(uint32_t model_id, const vector<uint64_t> & |
|
|
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]) { |
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "Static dims should be same, index:%zu value:%lu should be %ld", |
|
|
|
|
|
i, dynamic_dims[i], all_data_dims[i]); |
|
|
GELOGE(ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID, |
|
|
GELOGE(ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID, |
|
|
"Static dims should be same, index: %zu value: %lu should be %ld", |
|
|
|
|
|
|
|
|
"[Check][Param] Static dims should be same, index:%zu value:%lu should be %ld", |
|
|
i, dynamic_dims[i], all_data_dims[i]); |
|
|
i, dynamic_dims[i], all_data_dims[i]); |
|
|
return ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID; |
|
|
return ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID; |
|
|
} |
|
|
} |
|
@@ -496,12 +546,14 @@ 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(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "GeExecutor has not been initialized, model id:%u", model_id); |
|
|
|
|
|
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "[Check][Param] GeExecutor has not been initialized, model id:%u", model_id); |
|
|
return ACL_ERROR_GE_EXEC_NOT_INIT; |
|
|
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) { |
|
|
GELOGE(ret, "Get current shape failed"); |
|
|
|
|
|
|
|
|
REPORT_CALL_ERROR("E19999", "Get Cur Shape failed, model id:%u", model_id); |
|
|
|
|
|
GELOGE(ret, "[Get][CurShape] failed, model id:%u", model_id); |
|
|
return ret; |
|
|
return ret; |
|
|
} |
|
|
} |
|
|
return SUCCESS; |
|
|
return SUCCESS; |
|
@@ -512,11 +564,14 @@ 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(ACL_ERROR_GE_DYNAMIC_INPUT_ADDR_INVALID, "Dynamic aipp input addr is nullptr!"); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "Param dynamic_input_addr is nullptr, check invalid, model id:%u", model_id); |
|
|
|
|
|
GELOGE(ACL_ERROR_GE_DYNAMIC_INPUT_ADDR_INVALID, |
|
|
|
|
|
"[Check][Param] Dynamic aipp input addr is nullptr, model id:%u", model_id); |
|
|
return ACL_ERROR_GE_DYNAMIC_INPUT_ADDR_INVALID; |
|
|
return ACL_ERROR_GE_DYNAMIC_INPUT_ADDR_INVALID; |
|
|
} |
|
|
} |
|
|
if (aippBatchPara.empty()) { |
|
|
if (aippBatchPara.empty()) { |
|
|
GELOGE(ACL_ERROR_GE_AIPP_BATCH_EMPTY, "aippBatchPara is empty."); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "Param aippBatchPara is empty, check invalid, model id:%u", model_id); |
|
|
|
|
|
GELOGE(ACL_ERROR_GE_AIPP_BATCH_EMPTY, "[Check][Param] aippBatchPara is empty, model id:%u", model_id); |
|
|
return ACL_ERROR_GE_AIPP_BATCH_EMPTY; |
|
|
return ACL_ERROR_GE_AIPP_BATCH_EMPTY; |
|
|
} |
|
|
} |
|
|
uint64_t batch_num = aippBatchPara.size(); |
|
|
uint64_t batch_num = aippBatchPara.size(); |
|
@@ -527,14 +582,18 @@ 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) { |
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "input dynamic aipp param len:%lu is larger than aipp_data size:%lu", |
|
|
|
|
|
struct_len, length); |
|
|
GELOGE(ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_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); |
|
|
|
|
|
|
|
|
"[Check][Param] input dynamic aipp param len [%lu] is larger than aipp_data size [%lu]", |
|
|
|
|
|
struct_len, length); |
|
|
return ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID; |
|
|
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_ret, "memcpy real_aippParms_size failed! ret: 0x%X", rt_ret); |
|
|
|
|
|
|
|
|
REPORT_CALL_ERROR("E19999", "Call rtMemcpy failed, size:%lu, ret:0x%X", length, rt_ret); |
|
|
|
|
|
GELOGE(rt_ret, "[Call][RtMemcpy] memcpy aippParms failed! size:%lu, ret:0x%X", length, 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; |
|
@@ -545,7 +604,8 @@ 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_ret, "memcpy kAippDynamicBatchPara input data failed! ret: 0x%X", rt_ret); |
|
|
|
|
|
|
|
|
REPORT_CALL_ERROR("E19999", "Call rtMemcpy failed, ret:0x%X", rt_ret); |
|
|
|
|
|
GELOGE(rt_ret, "[Call][RtMemcpy] 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); |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
@@ -555,12 +615,14 @@ Status GeExecutor::SetDynamicAippData(uint32_t model_id, void *dynamic_input_add |
|
|
Status GeExecutor::UnloadModel(uint32_t model_id) { |
|
|
Status GeExecutor::UnloadModel(uint32_t model_id) { |
|
|
GELOGD("unload model %u begin.", model_id); |
|
|
GELOGD("unload model %u begin.", model_id); |
|
|
if (!isInit_) { |
|
|
if (!isInit_) { |
|
|
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "GeExecutor has not been initialized"); |
|
|
|
|
|
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "[Check][Param] GeExecutor has not been initialized!"); |
|
|
return ACL_ERROR_GE_EXEC_NOT_INIT; |
|
|
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); |
|
|
|
|
|
|
|
|
REPORT_CALL_ERROR("E19999", "Destroy Aicpu Session For Infer failed, model id:%u", model_id); |
|
|
|
|
|
GELOGE(ret, "[Destroy][AicpuSession] For Infer failed. model id:%u", model_id); |
|
|
return ret; |
|
|
return ret; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
@@ -578,7 +640,8 @@ Status GeExecutor::UnloadModel(uint32_t model_id) { |
|
|
} |
|
|
} |
|
|
ret = GraphLoader::UnloadModel(model_id); |
|
|
ret = GraphLoader::UnloadModel(model_id); |
|
|
if (ret != SUCCESS) { |
|
|
if (ret != SUCCESS) { |
|
|
GELOGE(ret, "[GraphLoader] DestroyAicpuSessionForInfer failed. model id: %u", model_id); |
|
|
|
|
|
|
|
|
REPORT_CALL_ERROR("E19999", "unload model failed, model id:%u", model_id); |
|
|
|
|
|
GELOGE(ret, "[Unload][Model] failed. model id:%u", model_id); |
|
|
return ret; |
|
|
return ret; |
|
|
} |
|
|
} |
|
|
return SUCCESS; |
|
|
return SUCCESS; |
|
@@ -588,7 +651,8 @@ Status GeExecutor::UnloadModel(uint32_t model_id) { |
|
|
Status GeExecutor::GetModelDescInfo(uint32_t model_id, std::vector<ge::TensorDesc> &input_desc, |
|
|
Status GeExecutor::GetModelDescInfo(uint32_t model_id, std::vector<ge::TensorDesc> &input_desc, |
|
|
std::vector<ge::TensorDesc> &output_desc, bool new_model_desc) { |
|
|
std::vector<ge::TensorDesc> &output_desc, bool new_model_desc) { |
|
|
if (!isInit_) { |
|
|
if (!isInit_) { |
|
|
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "GeExecutor has not been initialized, model id:%u", model_id); |
|
|
|
|
|
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "[Check][Param] GeExecutor has not been initialized, model id:%u", model_id); |
|
|
return ACL_ERROR_GE_EXEC_NOT_INIT; |
|
|
return ACL_ERROR_GE_EXEC_NOT_INIT; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
@@ -600,20 +664,26 @@ Status GeExecutor::GetModelDescInfo(uint32_t model_id, std::vector<ge::TensorDes |
|
|
Status ret = GraphExecutor::GetInputOutputDescInfo(model_id, input_desc_infos, output_desc_infos, input_formats, |
|
|
Status ret = GraphExecutor::GetInputOutputDescInfo(model_id, input_desc_infos, output_desc_infos, input_formats, |
|
|
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); |
|
|
|
|
|
|
|
|
REPORT_CALL_ERROR("E19999", "get input output desc info failed, ret = %u, model id:%u", ret, model_id); |
|
|
|
|
|
GELOGE(ret, "[Get][InputOutputDescInfo] failed. ret = %u, model id:%u", ret, model_id); |
|
|
return ACL_ERROR_GE_GET_TENSOR_INFO; |
|
|
return ACL_ERROR_GE_GET_TENSOR_INFO; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
if (input_formats.size() != input_desc_infos.size()) { |
|
|
if (input_formats.size() != input_desc_infos.size()) { |
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "input_formats size %zu is not equal to input_desc_infos size %zu, model id:%u.", |
|
|
|
|
|
input_formats.size(), input_desc_infos.size(), model_id); |
|
|
GELOGE(ACL_ERROR_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()); |
|
|
|
|
|
|
|
|
"[Check][Param] input_formats size %zu is not equal to input_desc_infos size %zu, model id:%u.", |
|
|
|
|
|
input_formats.size(), input_desc_infos.size(), model_id); |
|
|
return ACL_ERROR_GE_PARAM_INVALID; |
|
|
return ACL_ERROR_GE_PARAM_INVALID; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
if (output_formats.size() != output_desc_infos.size()) { |
|
|
if (output_formats.size() != output_desc_infos.size()) { |
|
|
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()); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "output_formats size %zu is not equal to output_desc_infos size %zu, model id:%u.", |
|
|
|
|
|
output_formats.size(), output_desc_infos.size(), model_id); |
|
|
|
|
|
GELOGE(ACL_ERROR_GE_PARAM_INVALID, |
|
|
|
|
|
"[Check][Param] output_formats size %zu is not equal to output_desc_infos size %zu, model id:%u.", |
|
|
|
|
|
output_formats.size(), output_desc_infos.size(), model_id); |
|
|
return ACL_ERROR_GE_PARAM_INVALID; |
|
|
return ACL_ERROR_GE_PARAM_INVALID; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
@@ -635,13 +705,15 @@ Status GeExecutor::GetModelDescInfo(uint32_t model_id, std::vector<ge::TensorDes |
|
|
Status GeExecutor::GetDynamicBatchInfo(uint32_t model_id, std::vector<std::vector<int64_t>> &batch_info, |
|
|
Status GeExecutor::GetDynamicBatchInfo(uint32_t model_id, std::vector<std::vector<int64_t>> &batch_info, |
|
|
int32_t &dynamic_type) { |
|
|
int32_t &dynamic_type) { |
|
|
if (!isInit_) { |
|
|
if (!isInit_) { |
|
|
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "GeExecutor has not been initialized!"); |
|
|
|
|
|
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "[Check][Param] GeExecutor has not been initialized!"); |
|
|
return ACL_ERROR_GE_EXEC_NOT_INIT; |
|
|
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); |
|
|
if (ret != SUCCESS) { |
|
|
if (ret != SUCCESS) { |
|
|
GELOGE(ret, "GetDynamicBatchInfo failed."); |
|
|
|
|
|
|
|
|
REPORT_CALL_ERROR("E19999", "Get Dynamic BatchInfo failed, model id:%u.", model_id); |
|
|
|
|
|
GELOGE(ret, "[Get][DynamicBatchInfo] failed, model id:%u.", model_id); |
|
|
return ret; |
|
|
return ret; |
|
|
} |
|
|
} |
|
|
return SUCCESS; |
|
|
return SUCCESS; |
|
@@ -657,13 +729,15 @@ 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(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "GeExecutor has not been initialized!"); |
|
|
|
|
|
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "[Check][Param] GeExecutor has not been initialized!"); |
|
|
return ACL_ERROR_GE_EXEC_NOT_INIT; |
|
|
return ACL_ERROR_GE_EXEC_NOT_INIT; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
Status ret = GraphExecutor::GetCombinedDynamicDims(model_id, batch_info); |
|
|
Status ret = GraphExecutor::GetCombinedDynamicDims(model_id, batch_info); |
|
|
if (ret != SUCCESS) { |
|
|
if (ret != SUCCESS) { |
|
|
GELOGE(ret, "GetCombinedDynamicDims failed."); |
|
|
|
|
|
|
|
|
REPORT_CALL_ERROR("E19999", "Get Combined DynamicDims failed, model id:%u.", model_id); |
|
|
|
|
|
GELOGE(ret, "[Get][CombinedDynamicDims] failed, model id:%u.", model_id); |
|
|
return ret; |
|
|
return ret; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
@@ -680,13 +754,15 @@ 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) { |
|
|
if (!isInit_) { |
|
|
if (!isInit_) { |
|
|
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "GeExecutor has not been initialized!"); |
|
|
|
|
|
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "[Check][Param] GeExecutor has not been initialized!"); |
|
|
return ACL_ERROR_GE_EXEC_NOT_INIT; |
|
|
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); |
|
|
if (ret != SUCCESS) { |
|
|
if (ret != SUCCESS) { |
|
|
GELOGE(ret, "GetUserDesignateShapeOrder failed."); |
|
|
|
|
|
|
|
|
REPORT_CALL_ERROR("E19999", "GetUserDesignateShapeOrder failed, model id:%u.", model_id); |
|
|
|
|
|
GELOGE(ret, "[Call][GetUserDesignateShapeOrder] failed, model id:%u.", model_id); |
|
|
return ret; |
|
|
return ret; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
@@ -704,7 +780,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(ACL_ERROR_GE_EXEC_NOT_INIT, "not inited yet!"); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "GeExecutor has not been initialized!"); |
|
|
|
|
|
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "[Check][Param] GeExecutor not inited yet!"); |
|
|
return ACL_ERROR_GE_EXEC_NOT_INIT; |
|
|
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); |
|
@@ -719,7 +796,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(ACL_ERROR_GE_EXEC_NOT_INIT, "not inited yet!"); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "GeExecutor has not been initialized!"); |
|
|
|
|
|
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not inited yet!"); |
|
|
return ACL_ERROR_GE_EXEC_NOT_INIT; |
|
|
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); |
|
@@ -741,8 +819,10 @@ Status GeExecutor::GetOpAttr(uint32_t model_id, const std::string &op_name, cons |
|
|
} |
|
|
} |
|
|
Status ret = GraphExecutor::GetOpAttr(model_id, op_name, attr_name, attr_value); |
|
|
Status ret = GraphExecutor::GetOpAttr(model_id, op_name, attr_name, attr_value); |
|
|
if (ret != SUCCESS) { |
|
|
if (ret != SUCCESS) { |
|
|
GELOGE(ret, "[Get][OpAttr]Get op:%s attr:%s failed.", op_name.c_str(), attr_name.c_str()); |
|
|
|
|
|
REPORT_CALL_ERROR("E19999", "Get op:%s attr:%s failed.", op_name.c_str(), attr_name.c_str()); |
|
|
|
|
|
|
|
|
GELOGE(ret, "[Get][OpAttr]Get op:%s attr:%s failed, model id:%u.", |
|
|
|
|
|
op_name.c_str(), attr_name.c_str(), model_id); |
|
|
|
|
|
REPORT_CALL_ERROR("E19999", "Get op:%s attr:%s failed, model id:%u", |
|
|
|
|
|
op_name.c_str(), attr_name.c_str(), model_id); |
|
|
return ret; |
|
|
return ret; |
|
|
} |
|
|
} |
|
|
return SUCCESS; |
|
|
return SUCCESS; |
|
@@ -750,12 +830,14 @@ Status GeExecutor::GetOpAttr(uint32_t model_id, const std::string &op_name, cons |
|
|
|
|
|
|
|
|
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) { |
|
|
if (!isInit_) { |
|
|
if (!isInit_) { |
|
|
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "not inited yet!"); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "GeExecutor has not inited yet!"); |
|
|
|
|
|
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "[Check][Param] GeExecutor has not inited yet!"); |
|
|
return ACL_ERROR_GE_EXEC_NOT_INIT; |
|
|
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) { |
|
|
GELOGE(ret, "Get dynamic batch output shape info failed."); |
|
|
|
|
|
|
|
|
REPORT_CALL_ERROR("E19999", "Get Model Attr failed, model id:%u.", model_id); |
|
|
|
|
|
GELOGE(ret, "[Get][ModelAttr] failed, model id:%u.", model_id); |
|
|
return ret; |
|
|
return ret; |
|
|
} |
|
|
} |
|
|
return SUCCESS; |
|
|
return SUCCESS; |
|
@@ -764,7 +846,8 @@ Status GeExecutor::GetModelAttr(uint32_t model_id, std::vector<std::string> &dyn |
|
|
Status GeExecutor::CommandHandle(const Command &command) { |
|
|
Status GeExecutor::CommandHandle(const Command &command) { |
|
|
Status ret = GraphLoader::CommandHandle(command); |
|
|
Status ret = GraphLoader::CommandHandle(command); |
|
|
if (ret != SUCCESS) { |
|
|
if (ret != SUCCESS) { |
|
|
GELOGE(ACL_ERROR_GE_COMMAND_HANDLE, "CommandHandle: Command Handle failed."); |
|
|
|
|
|
|
|
|
REPORT_CALL_ERROR("E19999", "call CommandHandle failed, ret:%u", ret); |
|
|
|
|
|
GELOGE(ACL_ERROR_GE_COMMAND_HANDLE, "[Call][CommandHandle] failed, ret:%u", ret); |
|
|
return ACL_ERROR_GE_COMMAND_HANDLE; |
|
|
return ACL_ERROR_GE_COMMAND_HANDLE; |
|
|
} |
|
|
} |
|
|
return SUCCESS; |
|
|
return SUCCESS; |
|
@@ -773,7 +856,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(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "GeExecutor has not been initialized!"); |
|
|
|
|
|
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "[Check][Param] GeExecutor has not been initialized!"); |
|
|
return ACL_ERROR_GE_EXEC_NOT_INIT; |
|
|
return ACL_ERROR_GE_EXEC_NOT_INIT; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
@@ -793,14 +877,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(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "GeExecutor has not been initialized!"); |
|
|
|
|
|
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "[Check][Param] GeExecutor has not been initialized!"); |
|
|
return ACL_ERROR_GE_EXEC_NOT_INIT; |
|
|
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(ACL_ERROR_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()); |
|
|
|
|
|
|
|
|
"[Call][RealPath] File path is invalid. please check your text file '%s'.", path.c_str()); |
|
|
return ACL_ERROR_GE_EXEC_MODEL_PATH_INVALID; |
|
|
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()); |
|
@@ -829,7 +914,8 @@ Status GeExecutor::LoadDataFromFile(const std::string &path, ModelData &model_da |
|
|
Status GeExecutor::LoadModelFromData(uint32_t &model_id, const ModelData &model_data, void *dev_ptr, size_t mem_size, |
|
|
Status GeExecutor::LoadModelFromData(uint32_t &model_id, const ModelData &model_data, void *dev_ptr, size_t mem_size, |
|
|
void *weight_ptr, size_t weight_size) { |
|
|
void *weight_ptr, size_t weight_size) { |
|
|
if (!isInit_) { |
|
|
if (!isInit_) { |
|
|
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "not inited yet!"); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "GeExecutor has not been initialized!"); |
|
|
|
|
|
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "[Check][Param] GeExecutor has not inited yet!"); |
|
|
return ACL_ERROR_GE_EXEC_NOT_INIT; |
|
|
return ACL_ERROR_GE_EXEC_NOT_INIT; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
@@ -850,7 +936,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(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "GeExecutor has not been initialized!"); |
|
|
|
|
|
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "[Check][Param] GeExecutor has not been initialized!"); |
|
|
return ACL_ERROR_GE_EXEC_NOT_INIT; |
|
|
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); |
|
@@ -889,7 +976,8 @@ Status GeExecutor::ExecModel(uint32_t model_id, void *stream, const ge::RunModel |
|
|
const std::vector<GeTensorDesc> &input_desc, ge::RunModelData &run_output_data, |
|
|
const std::vector<GeTensorDesc> &input_desc, ge::RunModelData &run_output_data, |
|
|
std::vector<GeTensorDesc> &output_desc, bool async_mode) { |
|
|
std::vector<GeTensorDesc> &output_desc, bool async_mode) { |
|
|
if (!isInit_) { |
|
|
if (!isInit_) { |
|
|
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "GeExecutor has not been initialized!"); |
|
|
|
|
|
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "[Check][Param] GeExecutor has not been initialized!"); |
|
|
return ACL_ERROR_GE_EXEC_NOT_INIT; |
|
|
return ACL_ERROR_GE_EXEC_NOT_INIT; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
@@ -904,7 +992,8 @@ Status GeExecutor::ExecModel(uint32_t model_id, void *stream, const ge::RunModel |
|
|
int32_t dynamic_type = static_cast<int32_t>(FIXED); |
|
|
int32_t dynamic_type = static_cast<int32_t>(FIXED); |
|
|
Status ret = GraphExecutor::GetDynamicBatchInfo(model_id, batch_info, dynamic_type); |
|
|
Status ret = GraphExecutor::GetDynamicBatchInfo(model_id, batch_info, dynamic_type); |
|
|
if (ret != SUCCESS) { |
|
|
if (ret != SUCCESS) { |
|
|
GELOGE(ret, "Get dynamic input info failed."); |
|
|
|
|
|
|
|
|
REPORT_CALL_ERROR("E19999", "get dynamic batch info failed, model id:%u.", model_id); |
|
|
|
|
|
GELOGE(ret, "[Get][DynamicBatchInfo] failed, model id:%u.", model_id); |
|
|
return ret; |
|
|
return ret; |
|
|
} |
|
|
} |
|
|
if (!batch_info.empty()) { |
|
|
if (!batch_info.empty()) { |
|
@@ -926,14 +1015,16 @@ 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(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "GeExecutor has not been initialized!"); |
|
|
|
|
|
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "[Check][Param] GeExecutor has not been initialized!"); |
|
|
return ACL_ERROR_GE_EXEC_NOT_INIT; |
|
|
return ACL_ERROR_GE_EXEC_NOT_INIT; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
ModelData model; |
|
|
ModelData model; |
|
|
Status ret = ge::GraphLoader::LoadDataFromFile(path, 0, model); |
|
|
Status ret = ge::GraphLoader::LoadDataFromFile(path, 0, model); |
|
|
if ((ret != SUCCESS) || (model.model_data == nullptr)) { |
|
|
if ((ret != SUCCESS) || (model.model_data == nullptr)) { |
|
|
GELOGE(ret, "Load data from file failed. ret = %d", ret); |
|
|
|
|
|
|
|
|
REPORT_CALL_ERROR("E19999", "load data from file failed, ret = %d", ret); |
|
|
|
|
|
GELOGE(ret, "[Load][Data] from file failed. ret = %d", ret); |
|
|
return ret; |
|
|
return ret; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
@@ -958,12 +1049,14 @@ 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(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "GeExecutor has not been initialized!"); |
|
|
|
|
|
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "[Check][Param] GeExecutor has not been initialized!"); |
|
|
return ACL_ERROR_GE_EXEC_NOT_INIT; |
|
|
return ACL_ERROR_GE_EXEC_NOT_INIT; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
if (model_data == nullptr) { |
|
|
if (model_data == nullptr) { |
|
|
GELOGE(ACL_ERROR_GE_EXEC_MODEL_ADDR_INVALID, "invalid model data!"); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "param model_data is nullptr, check invalid!"); |
|
|
|
|
|
GELOGE(ACL_ERROR_GE_EXEC_MODEL_ADDR_INVALID, "[Check][Param] invalid model data!"); |
|
|
return ACL_ERROR_GE_EXEC_MODEL_ADDR_INVALID; |
|
|
return ACL_ERROR_GE_EXEC_MODEL_ADDR_INVALID; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
@@ -997,7 +1090,8 @@ Status GeExecutor::LoadDynamicSingleOpV2(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(ACL_ERROR_GE_EXEC_NOT_INIT, "param is NULL"); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "Param executor is nullptr, check invalid"); |
|
|
|
|
|
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "[Check][Param] param executor is nullptr"); |
|
|
return ACL_ERROR_GE_EXEC_NOT_INIT; |
|
|
return ACL_ERROR_GE_EXEC_NOT_INIT; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
@@ -1021,7 +1115,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(ACL_ERROR_GE_EXEC_MODEL_ID_INVALID, "Model id: %d is invaild or model is not loaded.", model_id); |
|
|
|
|
|
|
|
|
GELOGE(ACL_ERROR_GE_EXEC_MODEL_ID_INVALID, |
|
|
|
|
|
"[Get][Model] failed, Model id:%u is invaild or model is not loaded.", model_id); |
|
|
return ACL_ERROR_GE_EXEC_MODEL_ID_INVALID; |
|
|
return ACL_ERROR_GE_EXEC_MODEL_ID_INVALID; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
@@ -1034,7 +1129,7 @@ Status GeExecutor::GetBatchInfoSize(uint32_t model_id, size_t &shape_count) { |
|
|
int32_t dynamic_type = static_cast<int32_t>(FIXED); |
|
|
int32_t dynamic_type = static_cast<int32_t>(FIXED); |
|
|
Status ret = GetDynamicBatchInfo(model_id, batch_info, dynamic_type); |
|
|
Status ret = GetDynamicBatchInfo(model_id, batch_info, dynamic_type); |
|
|
if (ret != SUCCESS) { |
|
|
if (ret != SUCCESS) { |
|
|
GELOGE(ret, "Calc batch info size failed. ret = %d", ret); |
|
|
|
|
|
|
|
|
GELOGE(ret, "[Get][DynamicBatchInfo] failed. ret = %d, model id:%u", ret, model_id); |
|
|
return ret; |
|
|
return ret; |
|
|
} |
|
|
} |
|
|
if (batch_info.empty()) { |
|
|
if (batch_info.empty()) { |
|
@@ -1048,13 +1143,15 @@ 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(ACL_ERROR_GE_EXEC_NOT_INIT, "not inited yet!"); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "GeExecutor has not been initialized!"); |
|
|
|
|
|
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "[Check][Param] GeExecutor has not been initialized!"); |
|
|
return ACL_ERROR_GE_EXEC_NOT_INIT; |
|
|
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); |
|
|
if (ret != SUCCESS) { |
|
|
if (ret != SUCCESS) { |
|
|
GELOGE(ret, "GetOrigInputInfo failed."); |
|
|
|
|
|
|
|
|
REPORT_CALL_ERROR("E19999", "Get Orig Input Info failed, model id:%u.", model_id); |
|
|
|
|
|
GELOGE(ret, "[Get][OrigInputInfo] failed, model id:%u.", model_id); |
|
|
return ret; |
|
|
return ret; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
@@ -1067,13 +1164,15 @@ 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(ACL_ERROR_GE_EXEC_NOT_INIT, "not inited yet!"); |
|
|
|
|
|
|
|
|
REPORT_INNER_ERROR("E19999", "GeExecutor has not been initialized!"); |
|
|
|
|
|
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "[Check][Param] GeExecutor has not been initialized!"); |
|
|
return ACL_ERROR_GE_EXEC_NOT_INIT; |
|
|
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); |
|
|
if (ret != SUCCESS) { |
|
|
if (ret != SUCCESS) { |
|
|
GELOGE(ret, "GetAllAippInputOutputDims failed."); |
|
|
|
|
|
|
|
|
REPORT_CALL_ERROR("E19999", "Get All Aipp Input Output Dims failed, model id:%u.", model_id); |
|
|
|
|
|
GELOGE(ret, "[Get][AllAippInputOutputDims] failed, model id:%u.", model_id); |
|
|
return ret; |
|
|
return ret; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
@@ -1085,7 +1184,10 @@ Status GeExecutor::GetOpDescInfo(uint32_t device_id, uint32_t stream_id, uint32_ |
|
|
GELOGI("Begin to GetOpDescInfo."); |
|
|
GELOGI("Begin to GetOpDescInfo."); |
|
|
Status ret = GraphExecutor::GetOpDescInfo(device_id, stream_id, task_id, op_desc_info); |
|
|
Status ret = GraphExecutor::GetOpDescInfo(device_id, stream_id, task_id, op_desc_info); |
|
|
if (ret != SUCCESS) { |
|
|
if (ret != SUCCESS) { |
|
|
GELOGE(ret, "GetOpDescInfo failed."); |
|
|
|
|
|
|
|
|
REPORT_CALL_ERROR("E19999", "get opdesc info failed, device_id:%u, stream_id:%u, task_id:%u.", |
|
|
|
|
|
device_id, stream_id, task_id); |
|
|
|
|
|
GELOGE(ret, "[Get][OpDescInfo] failed, device_id:%u, stream_id:%u, task_id:%u.", |
|
|
|
|
|
device_id, stream_id, task_id); |
|
|
return ret; |
|
|
return ret; |
|
|
} |
|
|
} |
|
|
GELOGI("GetOpDescInfo succ."); |
|
|
GELOGI("GetOpDescInfo succ."); |
|
@@ -1096,7 +1198,7 @@ Status GeExecutor::SetDump(const DumpConfig &dump_config) { |
|
|
GELOGI("Start to set dump config"); |
|
|
GELOGI("Start to set dump config"); |
|
|
auto ret = DumpManager::GetInstance().SetDumpConf(dump_config); |
|
|
auto ret = DumpManager::GetInstance().SetDumpConf(dump_config); |
|
|
if (ret != SUCCESS) { |
|
|
if (ret != SUCCESS) { |
|
|
GELOGE(ret, "Set dump conf failed"); |
|
|
|
|
|
|
|
|
GELOGE(ret, "[Set][DumpConf] failed, ret:%d", ret); |
|
|
return ret; |
|
|
return ret; |
|
|
} |
|
|
} |
|
|
GELOGI("Set dump config successfully"); |
|
|
GELOGI("Set dump config successfully"); |
|
|