hummingbird
/
graphengine
Not watched
2
0
Fork 0
Code
Releases 13 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
Browse Source

modify ge_log_error

tags/v1.5.1
liudingyan 3 years ago
parent
1af22f128c
commit
ae48888330
3 changed files with 194 additions and 92 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +189
    -87
      ge/executor/ge_executor.cc
  2. +1
    -2
      ge/graph/build/label_allocator.cc
  3. +4
    -3
      inc/framework/common/debug/ge_log.h

+ 189
- 87
ge/executor/ge_executor.cc View File

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

for (auto batch : batch_info) {
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;
}
if (batch[0] == static_cast<int64_t>(batch_size)) {
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;
}

bool IsDynamicImageSizeMatchModel(uint64_t image_height, uint64_t image_width,
const vector<std::vector<int64_t>> &batch_info) {
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;
}

for (auto resolution : batch_info) {
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());
return false;
}
@@ -160,22 +167,28 @@ bool IsDynamicImageSizeMatchModel(uint64_t image_height, uint64_t image_width,
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;
}

bool IsDynmaicDimsSizeMatchModel(const vector<uint64_t> cur_dynamic_dims,
const vector<vector<int64_t>> &batch_info) {
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;
}

bool find_match = false;
for (auto resolution : batch_info) {
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());
return false;
}
@@ -192,7 +205,7 @@ bool IsDynmaicDimsSizeMatchModel(const vector<uint64_t> cur_dynamic_dims,
}
}
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;
}
@@ -241,7 +254,7 @@ Status GeExecutor::Initialize() {

Status init_hostcpu_engine_status = HostCpuEngine::GetInstance().Initialize();
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;
}

@@ -251,12 +264,12 @@ Status GeExecutor::Initialize() {
mem_type.push_back(RT_MEMORY_P2P_DDR);
auto ret = MemManager::Instance().Initialize(mem_type);
if (ret != SUCCESS) {
GELOGE(ret, "Memory Manager init failed.");
GELOGE(ret, "[Initialize][MemManager] failed.");
return ret;
}

GE_CHK_STATUS_RET(OpsKernelBuilderManager::Instance().Initialize({}, false),
"Failed to initialize OpsKernelBuilders.");
"[Initialize][OpsKernelBuilderManager] failed.");

// Start profiling
Options profiling_options;
@@ -292,13 +305,18 @@ Status GeExecutor::Finalize() {
Status GeExecutor::SetDynamicBatchSize(uint32_t model_id, void *dynamic_input_addr, uint64_t length,
uint64_t batch_size) {
if (dynamic_input_addr == nullptr) {
GELOGE(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;
}

uint64_t size = sizeof(uint32_t);
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;
}
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);
Status ret = GraphExecutor::GetDynamicBatchInfo(model_id, batch_info, dynamic_type);
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;
}

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

ret = GraphExecutor::SetDynamicSize(model_id, batch_num, static_cast<int32_t>(DYNAMIC_BATCH));
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;
}
// memcpy dynamic_batch_size from host to device
rtError_t rt_ret = rtMemcpy(dynamic_input_addr, length, &batch_size, size, RT_MEMCPY_HOST_TO_DEVICE);
if (rt_ret != RT_ERROR_NONE) {
GELOGE(rt_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 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,
uint64_t image_height, uint64_t image_width) {
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;
}

uint64_t dynamic_input_size = kDynamicImageSizeInputSize * sizeof(uint32_t);
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,
"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;
}
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);
Status ret = GraphExecutor::GetDynamicBatchInfo(model_id, batch_info, dynamic_type);
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;
}

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

ret = GraphExecutor::SetDynamicSize(model_id, batch_num, static_cast<int32_t>(DYNAMIC_IMAGE));
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;
}

@@ -376,7 +407,9 @@ Status GeExecutor::SetDynamicImageSize(uint32_t model_id, void *dynamic_input_ad
rtError_t rt_ret =
rtMemcpy(dynamic_input_addr, size, &image_height, size, RT_MEMCPY_HOST_TO_DEVICE);
if (rt_ret != RT_ERROR_NONE) {
GELOGE(rt_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);
}

@@ -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),
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!");
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 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,
const vector<uint64_t> &dynamic_dims) {
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;
}

vector<uint64_t> cur_dynamic_dims;
Status ret = GetCurDynamicDims(model_id, dynamic_dims, cur_dynamic_dims);
if (ret != SUCCESS) {
GELOGE(ret, "Set cur gear dynamic dims failed");
GELOGE(ret, "[Get][CurDynamicDims] failed, model id:%u", model_id);
return ret;
}
std::vector<std::vector<int64_t>> batch_info;
int32_t dynamic_type = static_cast<int32_t>(FIXED);
ret = GraphExecutor::GetDynamicBatchInfo(model_id, batch_info, dynamic_type);
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;
}

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

ret = GraphExecutor::SetDynamicSize(model_id, cur_dynamic_dims, static_cast<int32_t>(DYNAMIC_DIMS));
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;
}

size_t dynamic_dim_num = cur_dynamic_dims.size();
uint64_t dynamic_input_size = static_cast<uint64_t>(dynamic_dim_num * sizeof(uint32_t));
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,
"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;
}
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),
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!");
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);
}
}
@@ -454,14 +500,14 @@ Status GeExecutor::GetCurDynamicDims(uint32_t model_id, const vector<uint64_t> &
vector<ge::TensorDesc> output_desc;
auto ret = GetModelDescInfo(model_id, input_desc, output_desc);
if (ret != ge::SUCCESS) {
GELOGE(ret, "GetModelDescInfo failed.");
GELOGE(ret, "[Get][ModelDescInfo] failed, model id:%u.", model_id);
return ret;
}
vector<string> user_designate_shape_order;
vector<int64_t> all_data_dims;
ret = GetUserDesignateShapeOrder(model_id, user_designate_shape_order);
if (ret != ge::SUCCESS) {
GELOGE(ret, "GetUserDesignateShapeOrder failed.");
GELOGE(ret, "[Call][GetUserDesignateShapeOrder] failed, model id:%u.", model_id);
return ret;
}
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()){
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,
"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());
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) {
cur_dynamic_dims.push_back(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,
"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]);
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) {
GELOGI("Begin to get current shape");
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;
}
Status ret = GraphExecutor::GetCurShape(model_id, batch_info, dynamic_type);
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 SUCCESS;
@@ -512,11 +564,14 @@ Status GeExecutor::SetDynamicAippData(uint32_t model_id, void *dynamic_input_add
const kAippDynamicPara &aippParms) {
GELOGI("Enter to SetDynamicAippData.");
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;
}
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;
}
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",
model_id, length, batch_num, struct_len);
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,
"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;
}
// Memcpy real kAippDynamicBatchPara from host to device
rtError_t rt_ret = rtMemcpy(dynamic_input_addr, length, &aippParms, real_aippParms_size, RT_MEMCPY_HOST_TO_DEVICE);
if (rt_ret != RT_ERROR_NONE) {
GELOGE(rt_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);
}
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]),
sizeof(kAippDynamicBatchPara), RT_MEMCPY_HOST_TO_DEVICE);
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);
}
}
@@ -555,12 +615,14 @@ Status GeExecutor::SetDynamicAippData(uint32_t model_id, void *dynamic_input_add
Status GeExecutor::UnloadModel(uint32_t model_id) {
GELOGD("unload model %u begin.", model_id);
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;
}
Status ret = GraphLoader::DestroyAicpuSessionForInfer(model_id);
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;
}

@@ -578,7 +640,8 @@ Status GeExecutor::UnloadModel(uint32_t model_id) {
}
ret = GraphLoader::UnloadModel(model_id);
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 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,
std::vector<ge::TensorDesc> &output_desc, bool new_model_desc) {
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;
}

@@ -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,
output_formats, new_model_desc);
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;
}

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,
"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;
}

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

@@ -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,
int32_t &dynamic_type) {
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;
}

Status ret = GraphExecutor::GetDynamicBatchInfo(model_id, batch_info, dynamic_type);
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 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) {
GELOGI("Begin to get combined dynamic dims info.");
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;
}

Status ret = GraphExecutor::GetCombinedDynamicDims(model_id, batch_info);
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;
}

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

Status ret = GraphExecutor::GetUserDesignateShapeOrder(model_id, user_designate_shape_order);
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;
}

@@ -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) {
GELOGI("Begin to GetAIPPInfo.");
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;
}
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) {
GELOGI("Begin to get aipp type.");
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;
}
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);
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 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) {
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;
}
Status ret = GraphExecutor::GetModelAttr(model_id, dynamic_output_shape_info);
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 SUCCESS;
@@ -764,7 +846,8 @@ Status GeExecutor::GetModelAttr(uint32_t model_id, std::vector<std::string> &dyn
Status GeExecutor::CommandHandle(const Command &command) {
Status ret = GraphLoader::CommandHandle(command);
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 SUCCESS;
@@ -773,7 +856,8 @@ Status GeExecutor::CommandHandle(const Command &command) {
Status GeExecutor::GetMaxUsedMemory(uint32_t model_id, uint32_t &max_size) {
GELOGI("Get max used memory begin.");
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;
}

@@ -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) {
GELOGI("Load data from file begin.");
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;
}

string filePath = RealPath(path.c_str());
if (filePath.empty()) {
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;
}
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,
void *weight_ptr, size_t weight_size) {
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;
}

@@ -850,7 +936,8 @@ Status GeExecutor::LoadModelWithQ(uint32_t &model_id, const ModelData &model_dat
const std::vector<uint32_t> &output_queue_ids) {
GELOGI("Load model with queue begin.");
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 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,
std::vector<GeTensorDesc> &output_desc, bool async_mode) {
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;
}

@@ -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);
Status ret = GraphExecutor::GetDynamicBatchInfo(model_id, batch_info, dynamic_type);
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;
}
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) {
GELOGI("Get memory and weight size from file begin.");
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;
}

ModelData model;
Status ret = ge::GraphLoader::LoadDataFromFile(path, 0, model);
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;
}

@@ -958,12 +1049,14 @@ Status GeExecutor::GetMemAndWeightSize(const void *model_data, size_t model_size
size_t &weight_size) {
GELOGI("Get memory and weight size from data begin.");
if (!isInit_) {
GELOGE(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;
}

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

@@ -997,7 +1090,8 @@ Status GeExecutor::LoadDynamicSingleOpV2(const std::string &model_name, const ge
Status GeExecutor::ExecuteAsync(SingleOp *executor, const std::vector<DataBuffer> &inputs,
std::vector<DataBuffer> &outputs) {
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;
}

@@ -1021,7 +1115,8 @@ Status GeExecutor::GetDeviceIdByModelId(uint32_t model_id, uint32_t &device_id)
GE_CHECK_NOTNULL(model_manager);
auto davinci_model = model_manager->GetModel(model_id);
if (davinci_model == nullptr) {
GELOGE(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;
}

@@ -1034,7 +1129,7 @@ Status GeExecutor::GetBatchInfoSize(uint32_t model_id, size_t &shape_count) {
int32_t dynamic_type = static_cast<int32_t>(FIXED);
Status ret = GetDynamicBatchInfo(model_id, batch_info, dynamic_type);
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;
}
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) {
GELOGI("Begin to GetOrigInputInfo.");
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;
}

Status ret = GraphExecutor::GetOrigInputInfo(model_id, index, orig_input_info);
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;
}

@@ -1067,13 +1164,15 @@ Status GeExecutor::GetAllAippInputOutputDims(uint32_t model_id, uint32_t index,
std::vector<InputOutputDims> &output_dims) {
GELOGI("Begin to GetAllAippInputOutputDims.");
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;
}

Status ret = GraphExecutor::GetAllAippInputOutputDims(model_id, index, input_dims, output_dims);
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;
}

@@ -1085,7 +1184,10 @@ Status GeExecutor::GetOpDescInfo(uint32_t device_id, uint32_t stream_id, uint32_
GELOGI("Begin to GetOpDescInfo.");
Status ret = GraphExecutor::GetOpDescInfo(device_id, stream_id, task_id, op_desc_info);
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;
}
GELOGI("GetOpDescInfo succ.");
@@ -1096,7 +1198,7 @@ Status GeExecutor::SetDump(const DumpConfig &dump_config) {
GELOGI("Start to set dump config");
auto ret = DumpManager::GetInstance().SetDumpConf(dump_config);
if (ret != SUCCESS) {
GELOGE(ret, "Set dump conf failed");
GELOGE(ret, "[Set][DumpConf] failed, ret:%d", ret);
return ret;
}
GELOGI("Set dump config successfully");


+ 1
- 2
ge/graph/build/label_allocator.cc View File

@@ -80,8 +80,7 @@ bool LabelAllocator::CollectFunctionalNode(ComputeGraphPtr &graph, std::set<Node

NodePtr func_node = graph->GetParentNode();
if (func_node == nullptr) {
REPORT_INNER_ERROR("E19999", "Parent node not set in node:%s(%s), graph:%s",
func_node->GetName().c_str(), func_node->GetType().c_str(), graph->GetName().c_str());
REPORT_INNER_ERROR("E19999", "Parent node not set, graph:%s", graph->GetName().c_str());
GELOGE(INTERNAL_ERROR, "[Get][Node] Parent functional node not set: %s.", graph->GetName().c_str());
return false;
}


+ 4
- 3
inc/framework/common/debug/ge_log.h View File

@@ -84,9 +84,10 @@ inline bool IsLogEnable(int module_name, int log_level) {
##__VA_ARGS__); \
} while (0)

#define GE_LOG_ERROR(MOD_NAME, ERROR_CODE, fmt, ...) \
dlog_error(MOD_NAME, "%lu %s: ErrorNo: %d(%s) " fmt, GeLog::GetTid(), __FUNCTION__, ERROR_CODE, \
((GE_GET_ERRORNO_STR(ERROR_CODE)).c_str()), ##__VA_ARGS__)
#define GE_LOG_ERROR(MOD_NAME, ERROR_CODE, fmt, ...) \
dlog_error(MOD_NAME, "%lu %s: ErrorNo: %d(%s) %s" fmt, GeLog::GetTid(), __FUNCTION__, ERROR_CODE, \
((GE_GET_ERRORNO_STR(ERROR_CODE)).c_str()), ErrorManager::GetInstance().GetLogHeader().c_str(), \
##__VA_ARGS__)

// print memory when it is greater than 1KB.
#define GE_PRINT_DYNAMIC_MEMORY(FUNC, PURPOSE, SIZE) \


Write Preview
Loading…
Cancel
Save