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

!1107 fix

Browse Source 
Merge pull request !1107 from weiyang/fix
pull/1107/MERGE
weiyang 4 years ago committed by Gitee
parent 1d354d1e29 436c2c8688
commit 53980c56f3
5 changed files with 30 additions and 25 deletions
Show Stats Download Patch File Download Diff File

4
ge/common/helper/model_helper.cc
Unescape View File

@ -512,8 +512,8 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::LoadModel(c
FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::LoadRootModel(const ge::ModelData &model_data) {
if (model_data.model_data == nullptr || model_data.model_len == 0) {
GELOGE(GE_EXEC_MODEL_DATA_SIZE_INVALID, "Model_data is nullptr, or model_data_size is 0");
return GE_EXEC_MODEL_DATA_SIZE_INVALID;
GELOGE(ACL_ERROR_GE_EXEC_MODEL_DATA_SIZE_INVALID, "Model_data is nullptr, or model_data_size is 0");
return ACL_ERROR_GE_EXEC_MODEL_DATA_SIZE_INVALID;
}
if (is_assign_model_) {

9
ge/common/helper/om_file_helper.cc
Unescape View File

@ -207,9 +207,9 @@ Status OmFileLoadHelper::LoadModelPartitionTable(uint8_t *model_data, uint32_t m
"ModelFileHeader length :%zu, ModelPartitionTable length :%zu",
index, partition_table->num, sizeof(ModelFileHeader), partition_table_size);
if (model_data_size <= cur_offset) {
GELOGE(GE_EXEC_MODEL_DATA_SIZE_INVALID, "invalid model data, partition_table->num:%u, model data size %u",
GELOGE(ACL_ERROR_GE_EXEC_MODEL_DATA_SIZE_INVALID, "invalid model data, partition_table->num:%u, model data size %u",
partition_table->num, model_data_size);
return GE_EXEC_MODEL_DATA_SIZE_INVALID;
return ACL_ERROR_GE_EXEC_MODEL_DATA_SIZE_INVALID;
}
for (uint32_t i = 0; i < partition_table->num; i++) {
@ -231,9 +231,10 @@ Status OmFileLoadHelper::LoadModelPartitionTable(uint8_t *model_data, uint32_t m
}
if (partition.size > model_data_size || cur_offset > model_data_size - partition.size) {
GELOGE(GE_EXEC_MODEL_DATA_SIZE_INVALID, "The partition size %u is greater than the model data size %u.",
GELOGE(ACL_ERROR_GE_EXEC_MODEL_DATA_SIZE_INVALID,
"The partition size %u is greater than the model data size %u.",
partition.size + cur_offset, model_data_size);
return GE_EXEC_MODEL_DATA_SIZE_INVALID;
return ACL_ERROR_GE_EXEC_MODEL_DATA_SIZE_INVALID;
}
cur_offset += partition.size;
GELOGD("Partition, type:%d, size:%u, model_index:%u", static_cast<int>(partition.type), partition.size, index);

6
ge/executor/ge_executor.cc
Unescape View File

@ -175,14 +175,14 @@ bool IsDynamicImageSizeMatchModel(uint64_t image_height, uint64_t image_width,
bool IsDynmaicDimsSizeMatchModel(const vector<uint64_t> cur_dynamic_dims,
const vector<vector<int64_t>> &batch_info) {
if (batch_info.empty()) {
GELOGE(ge::FAILED, "Dynamic batch info is empty.");
GELOGE(ACL_ERROR_GE_PARAM_INVALID, "Dynamic batch info is empty.");
return false;
}
bool find_match = false;
for (auto resolution : batch_info) {
if (cur_dynamic_dims.size() != resolution.size()) {
GELOGE(ge::FAILED, "Cur dynamic dims param num is %zu, current resolution size is %zu.",
GELOGE(ACL_ERROR_GE_PARAM_INVALID, "Cur dynamic dims param num is %zu, current resolution size is %zu.",
cur_dynamic_dims.size(), resolution.size());
return false;
}
@ -199,7 +199,7 @@ bool IsDynmaicDimsSizeMatchModel(const vector<uint64_t> cur_dynamic_dims,
}
}
if (!find_match) {
GELOGE(ge::FAILED, "choose dynamic dims can not match the gear of model.");
GELOGE(ACL_ERROR_GE_PARAM_INVALID, "choose dynamic dims can not match the gear of model.");
}
return find_match;
}

30
ge/graph/load/model_manager/davinci_model.cc
Unescape View File

@ -3283,8 +3283,8 @@ bool DavinciModel::CheckInputAndModelSize(const int64_t &input_size, const int64
}
// The input and model input size can not be exactly equal because user input is not definite.
if ((input_size + kDataMemAlignSizeCompare) < op_size) {
GELOGE(FAILED, "Input size [%ld] can not be smaller than op size [%ld] after 64-byte alignment", input_size,
op_size);
GELOGE(ACL_ERROR_GE_PARAM_INVALID,
"Input size [%ld] can not be smaller than op size [%ld] after 64-byte alignment", input_size, op_size);
return false;
}
return true;
@ -3334,27 +3334,28 @@ Status DavinciModel::UpdateIoTaskArgs(const std::map<uint32_t, ZeroCopyOffset> &
string input_or_output = "input";
is_input ? input_or_output = "input" : input_or_output = "output";
if (blobs.size() != data_info.size()) {
GELOGE(FAILED, "Verify %s data num failed: model requires %zu, but user actually feeds %zu",
GELOGE(ACL_ERROR_GE_PARAM_INVALID, "Verify %s data num failed: model requires %zu, but user actually feeds %zu",
input_or_output.c_str(), data_info.size(), blobs.size());
return FAILED;
return ACL_ERROR_GE_PARAM_INVALID;
}
for (const auto &data : data_info) {
if (data.first >= blobs.size()) { // check data index.
GELOGE(FAILED, "Verify %s data num failed: can not find No.%u data, because user only feeds %zu",
GELOGE(ACL_ERROR_GE_PARAM_INVALID, "Verify %s data num failed: can not find No.%u data, because user only feeds %zu",
input_or_output.c_str(), data.first, blobs.size());
return FAILED;
return ACL_ERROR_GE_PARAM_INVALID;
}
const DataBuffer &buffer = blobs[data.first]; // index of data.
if (buffer.data == nullptr) {
GELOGE(FAILED, "data_buf.data is nullptr, index=%u", data.first);
return FAILED;
GELOGE(ACL_ERROR_GE_PARAM_INVALID, "data_buf.data is nullptr, index=%u", data.first);
return ACL_ERROR_GE_PARAM_INVALID;
}
if (!CheckInputAndModelSize(buffer.length, data.second.GetDataSize(), is_dynamic)) {
GELOGE(FAILED, "Check input size and model size failed, op[%s]", data.second.GetOpName().c_str());
return FAILED;
GELOGE(ACL_ERROR_GE_PARAM_INVALID,
"Check input size and model size failed, op[%s]", data.second.GetOpName().c_str());
return ACL_ERROR_GE_PARAM_INVALID;
}
void *basic_addr = data.second.GetBasicAddr();
@ -3362,9 +3363,10 @@ Status DavinciModel::UpdateIoTaskArgs(const std::map<uint32_t, ZeroCopyOffset> &
if (copy_only_addrs_.count(basic_addr) > 0) {
if (is_input) {
GELOGI("[IMAS] Find addr %p need direct copy from user malloc input %p", basic_addr, buffer.data);
if (rtMemcpy(basic_addr, data_size, buffer.data, buffer.length, RT_MEMCPY_DEVICE_TO_DEVICE) != RT_ERROR_NONE) {
GELOGE(FAILED, "Non-zero copy data node copy failed");
return FAILED;
rtError_t rt_ret = rtMemcpy(basic_addr, data_size, buffer.data, buffer.length, RT_MEMCPY_DEVICE_TO_DEVICE);
if (rt_ret != RT_ERROR_NONE) {
GELOGE(rt_ret, "Non-zero copy data node copy failed");
return RT_ERROR_TO_GE_STATUS(rt_ret);
}
}
GELOGI("No need to exeucte zero copy task because this addr %p need direct copy.", basic_addr);
@ -3385,7 +3387,7 @@ Status DavinciModel::UpdateIoTaskArgs(const std::map<uint32_t, ZeroCopyOffset> &
}
uintptr_t addr_val = reinterpret_cast<uintptr_t>(addr);
if (task.UpdateTaskParam(addr_val, buffer_addr) != SUCCESS) {
return FAILED;
return ACL_ERROR_GE_PARAM_INVALID;
}
}
}

6
ge/graph/load/model_manager/model_manager.cc
Unescape View File

@ -55,16 +55,18 @@ const char *const kDeleteCustOp = "deleteCustOp";
const int kTimeSpecNano = 1000000000;
const int kTimeSpecMiro = 1000000;
const int kOpNameMaxSize = 100;
#pragma pack(push, 1)
struct CustAicpuSoBuf {
uint64_t kernelSoBuf;
uint32_t kernelSoBufLen;
uint64_t kernelSoName;
uint32_t kernelSoNameLen;
} __attribute__((packed));
};
struct BatchLoadOpFromBufArgs {
uint32_t soNum;
uint64_t args;
} __attribute__((packed));
};
#pragma pack(pop)
} // namespace
DumpProperties ModelManager::dump_properties_;

Write Preview
Loading…
Cancel
Save