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

Merge branch 'master' of gitee.com:liyihan123/graphengine

Browse Source
pull/1373/head
liyihan2@huawei.com 4 years ago
parent 4ef1970f6d 3a4d332a83
commit 48ae6fcdb2
80 changed files with 2291 additions and 222 deletions
Show Stats Download Patch File Download Diff File

4
ge/common/dump/opdebug_register.cc
Unescape View File

@ -88,7 +88,6 @@ Status OpdebugRegister::RegisterDebugForStream(rtStream_t stream, uint32_t op_de
uint32_t debug_stream_id = 0;
uint32_t debug_task_id = 0;
#ifdef ONLY_COMPILE_OPEN_SRC
auto rt_ret = rtDebugRegisterForStream(stream, op_debug_mode, op_debug_addr_, &debug_stream_id, &debug_task_id);
if (rt_ret != RT_ERROR_NONE) {
GELOGE(RT_FAILED, "[Register][rtDebug]Failed in stream overflow, ret:0x%X, op_debug_mode:%u.",
@ -97,7 +96,6 @@ Status OpdebugRegister::RegisterDebugForStream(rtStream_t stream, uint32_t op_de
rt_ret, op_debug_mode);
return RT_ERROR_TO_GE_STATUS(rt_ret);
}
#endif
GELOGD("debug_task_id:%u, debug_stream_id:%u in stream overflow.", debug_task_id, debug_stream_id);
data_dumper.SaveOpDebugId(debug_task_id, debug_stream_id, p2p_debug_addr_, true);
return SUCCESS;
@ -105,7 +103,6 @@ Status OpdebugRegister::RegisterDebugForStream(rtStream_t stream, uint32_t op_de
void OpdebugRegister::UnregisterDebugForStream(rtStream_t stream) {
rtError_t rt_ret = RT_ERROR_NONE;
#ifdef ONLY_COMPILE_OPEN_SRC
if (stream != nullptr) {
GELOGD("start call rtDebugUnRegisterForStream in unknown shape over flow.");
rt_ret = rtDebugUnRegisterForStream(stream);
@ -113,7 +110,6 @@ void OpdebugRegister::UnregisterDebugForStream(rtStream_t stream) {
GELOGW("rtDebugUnRegisterForStream failed, ret: 0x%X", rt_ret);
}
}
#endif
if (op_debug_addr_ != nullptr) {
rt_ret = rtFree(op_debug_addr_);

149
ge/common/formats/format_transfers/format_transfer_fractal_z.cc
Unescape View File

@ -29,6 +29,25 @@
namespace ge {
namespace formats {
namespace {
constexpr int64_t kDim = 1;
static int64_t Measure(int64_t x, int64_t y) {
int64_t z = y;
while (x % y != 0) {
z = x % y;
x = y;
y = z;
}
return z;
}
// least common multiple
static int64_t Lcm(int64_t a, int64_t b) {
if (b == 0) {
return -1;
}
int64_t temp = (a * b) / (Measure(a, b));
return temp;
}
Status CheckDataTypeSupport(DataType data_type) { return GetSizeByDataType(data_type) > 0 ? SUCCESS : UNSUPPORTED; }
/**
@ -61,6 +80,35 @@ Status TransShapeToFz(int64_t n, int64_t c, int64_t h, int64_t w, DataType data_
return SUCCESS;
}
Status TransShapeToFzWithGroups(int64_t n, int64_t c, int64_t h, int64_t w, DataType data_type, std::vector<int64_t> &dst_shape,
int64_t groups) {
auto c0 = GetCubeSizeByDataType(data_type);
if (c0 < 0) {
return ACL_ERROR_GE_DATATYPE_INVALID;
}
int64_t cin_ori = c;
int64_t cout_ori = n / groups;
int64_t cube_k = GetCubeSizeByDataType(data_type);
int64_t e_mult = std::min(
Lcm(Lcm(cin_ori, cube_k) / (cin_ori), Lcm(cout_ori, static_cast<int64_t>(kCubeSize)) / (cout_ori)),
groups);
int64_t cin_opt = Ceil(e_mult * cin_ori, cube_k) * cube_k;
int64_t c1_dim = cin_opt / cube_k;
int64_t g_dim = Ceil(groups, e_mult);
auto n1 = Ceil(cout_ori * e_mult, static_cast<int64_t>(kCubeSize));
dst_shape.clear();
dst_shape.push_back(g_dim * c1_dim * h * w);
dst_shape.push_back(n1);
dst_shape.push_back(16);
dst_shape.push_back(cube_k);
if (!IsShapeValid(dst_shape)) {
GELOGE(ACL_ERROR_GE_SHAPE_INVALID, "Failed to check dst shape %s",
ShapeToString(dst_shape).c_str());
return ACL_ERROR_GE_SHAPE_INVALID;
}
return SUCCESS;
}
Status TransShapeNchwToFz(const std::vector<int64_t> &src_shape, DataType data_type, std::vector<int64_t> &dst_shape) {
if (!CheckShapeValid(src_shape, kNchwDimsNum)) {
return ACL_ERROR_GE_SHAPE_INVALID;
@ -86,6 +134,21 @@ Status TransShapeHwcnToFz(const std::vector<int64_t> &src_shape, DataType data_t
return TransShapeToFz(n, c, h, w, data_type, dst_shape);
}
Status TransShapeHwcnToFzWithGroups(const std::vector<int64_t> &src_shape, DataType data_type, std::vector<int64_t> &dst_shape
, int64_t groups){
if (!CheckShapeValid(src_shape, kHwcnDimsNum)) {
return ACL_ERROR_GE_SHAPE_INVALID;
}
auto h = src_shape.at(kHwcnH);
auto w = src_shape.at(kHwcnW);
auto c = src_shape.at(kHwcnC);
auto n = src_shape.at(kHwcnN);
return TransShapeToFzWithGroups(n, c, h, w, data_type, dst_shape, groups);
}
Status TransShapeNhwcToFz(const std::vector<int64_t> &src_shape, DataType data_type, std::vector<int64_t> &dst_shape) {
if (!CheckShapeValid(src_shape, kNhwcDimsNum)) {
return ACL_ERROR_GE_SHAPE_INVALID;
@ -189,6 +252,80 @@ Status TransFormatFromNchwToFz(const TransArgs &args, TransResult &result) {
return SUCCESS;
}
Status TransFormatHwcnToFzWithGroups(const TransArgs &args, TransResult &result, int64_t groups){
int64_t h_dim = args.src_shape[kHwcnH];
int64_t w_dim = args.src_shape[kHwcnW];
int64_t c_dim = args.src_shape[kHwcnC];
int64_t n_dim = args.src_shape[kHwcnN];
int64_t cin_ori = c_dim;
int64_t cout_ori = n_dim / groups;
if (cin_ori == 0 || cout_ori == 0) {
GELOGE(GRAPH_FAILED, "Cin_ori, cout_ori must not be equal 0, and current cin_ori, cout_ori,"
"groups are %ld %ld %ld",cin_ori, cout_ori, groups);
return GRAPH_FAILED;
}
const int64_t cube_k = GetCubeSizeByDataType(args.src_data_type);
int64_t e_mult = std::min(
Lcm(Lcm(cin_ori, cube_k) / (cin_ori), Lcm(cout_ori, static_cast<int64_t>(kCubeSize)) / (cout_ori)),
groups);
int64_t cin_opt = Ceil(e_mult * cin_ori, cube_k) * cube_k;
int64_t cout_opt = Ceil(e_mult * cout_ori, static_cast<int64_t>(kCubeSize)) * static_cast<int64_t>(kCubeSize);
int64_t c1_dim = cin_opt / cube_k;
int64_t g_dim = Ceil(groups, e_mult);
int64_t dim_cin = cin_opt / cube_k;
int64_t data_size = GetSizeByDataType(args.src_data_type);
int64_t size_output_data = g_dim * kDim * dim_cin * h_dim * w_dim * cout_opt * cube_k * data_size;
if (size_output_data == 0) {
result.length = static_cast<size_t>(size_output_data);
return SUCCESS;
}
errno_t ret = EOK;
std::shared_ptr<uint8_t> dst(new (std::nothrow) uint8_t[size_output_data], std::default_delete<uint8_t[]>());
if (dst == nullptr) {
GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "Failed to trans format from %s to %s, can not alloc the memory for dst buf %ld",
TypeUtils::FormatToSerialString(args.src_format).c_str(),
TypeUtils::FormatToSerialString(args.dst_format).c_str(), size_output_data);
return ACL_ERROR_GE_MEMORY_ALLOCATION;
}
ret = memset_s(dst.get(), static_cast<size_t>(size_output_data), 0, static_cast<size_t>(size_output_data));
if (ret != EOK) {
GELOGE(ACL_ERROR_GE_MEMORY_OPERATE_FAILED, "Failed to operate the dst memory, ret is %d", ret);
return ACL_ERROR_GE_MEMORY_OPERATE_FAILED;
}
for (int64_t g = 0; g < groups; g++) {
for (int64_t d = 0; d < kDim; d++) {
for (int64_t c = 0; c < c_dim; c++) {
for (int64_t h = 0; h < h_dim; h++) {
for (int64_t w = 0; w < w_dim; w++) {
for (int64_t n = 0; n < cout_ori; n++) {
int64_t e_val = g % e_mult;
int64_t dst_ci = e_val * cin_ori + c;
int64_t dst_co = e_val * cout_ori + n;
int64_t src_co = g * cout_ori + n;
int64_t tempory = dst_ci % cube_k;
int64_t srx_inx = 0;
int64_t dst_inx = (g / e_mult) * kDim * c1_dim * h_dim * w_dim * cout_opt * cube_k +
d * c1_dim * h_dim * w_dim * cout_opt * cube_k +
(dst_ci / cube_k) * h_dim * w_dim * cout_opt * cube_k +
h * w_dim * cout_opt * cube_k + w * cout_opt * cube_k +
dst_co * cube_k + tempory;
srx_inx = d * h_dim * w_dim * c_dim * n_dim + h * w_dim * c_dim * n_dim +
w * c_dim * n_dim + c * n_dim + src_co;
char *dst_data = reinterpret_cast<char *>(dst.get() + dst_inx * data_size);
const char *src_data = reinterpret_cast<const char *>(args.data + srx_inx * data_size);
for (int64_t index = 0; index < data_size; index++) {
*dst_data++ = *src_data++;
}
}
}
}
}
}
}
result.data = dst;
result.length = static_cast<size_t>(size_output_data);
return SUCCESS;
}
Status TransFormatHwcnToFz(const TransArgs &args, TransResult &result) {
int64_t h = args.src_shape[kHwcnH];
int64_t w = args.src_shape[kHwcnW];
@ -363,15 +500,16 @@ Status FormatTransferFractalZ::TransFormat(const TransArgs &args, TransResult &r
if (args.src_format == FORMAT_NHWC && args.dst_format == FORMAT_FRACTAL_Z) {
return TransFormatNhwcToFz(args, result);
}
if (args.src_format == FORMAT_HWCN && args.dst_format == FORMAT_FRACTAL_Z) {
if ((args.src_format == FORMAT_HWCN) && (GetPrimaryFormat(args.dst_format) == FORMAT_FRACTAL_Z)) {
if (GetSubFormat(args.dst_format) > 1) {
return TransFormatHwcnToFzWithGroups(args, result, GetSubFormat(args.dst_format));
}
return TransFormatHwcnToFz(args, result);
}
if (args.src_format == FORMAT_NCHW && args.dst_format == FORMAT_FRACTAL_Z) {
return TransFormatFromNchwToFz(args, result);
}
return ACL_ERROR_GE_FORMAT_INVALID;
}
@ -384,7 +522,10 @@ Status FormatTransferFractalZ::TransShape(Format src_format, const std::vector<i
if (src_format == FORMAT_NHWC && dst_format == FORMAT_FRACTAL_Z) {
return TransShapeNhwcToFz(src_shape, data_type, dst_shape);
}
if (src_format == FORMAT_HWCN && dst_format == FORMAT_FRACTAL_Z) {
if ((src_format == FORMAT_HWCN) && (GetPrimaryFormat(dst_format) == FORMAT_FRACTAL_Z)) {
if (GetSubFormat(dst_format) > 1) {
return TransShapeHwcnToFzWithGroups(src_shape, data_type, dst_shape, GetSubFormat(dst_format));
}
return TransShapeHwcnToFz(src_shape, data_type, dst_shape);
}
if (src_format == FORMAT_NCHW && dst_format == FORMAT_FRACTAL_Z) {

33
ge/common/profiling/profiling_manager.cc
Unescape View File

@ -31,7 +31,6 @@ const char *const kFpPoint = "fp_point";
const char *const kBpPoint = "bp_point";
#ifdef DAVINCI_SUPPORT_PROFILING
const size_t kReportMaxLen = 2048;
const int32_t kMaxDeviceNum = 256;
const uint32_t kInteval = 2;
const std::string kConfigNumsdev = "devNums";
@ -293,21 +292,22 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY void ProfilingManager::ReportDa
ReporterData reporter_data{};
int ret = -1;
int32_t cb_ret = -1;
size_t index = data.size() / kReportMaxLen;
size_t report_max_len = reporter_max_len_;
size_t index = data.size() / report_max_len;
if (index >= 1) {
reporter_data.deviceId = device_id;
ret = memcpy_s(reporter_data.tag, MSPROF_ENGINE_MAX_TAG_LEN + 1, tag_name.c_str(), tag_name.size());
GE_IF_BOOL_EXEC(ret != EOK, GELOGE(ret, "Report data tag [%s] memcpy error!", tag_name.c_str()); return;);
for (size_t i = 0; i < index; ++i) {
reporter_data.data = (unsigned char *)data.c_str() + kReportMaxLen * i;
reporter_data.dataLen = kReportMaxLen;
reporter_data.data = (unsigned char *)data.c_str() + report_max_len * i;
reporter_data.dataLen = report_max_len;
cb_ret = CallMsprofReport(reporter_data);
GE_IF_BOOL_EXEC(cb_ret != 0, GELOGE(cb_ret, "Reporter data [%s] failed, ret:%d", tag_name.c_str(), cb_ret);
return;);
}
reporter_data.dataLen = data.size() - kReportMaxLen * index;
reporter_data.dataLen = data.size() - report_max_len * index;
if (reporter_data.dataLen != 0) {
reporter_data.data = (unsigned char *)data.c_str() + kReportMaxLen * index;
reporter_data.data = (unsigned char *)data.c_str() + report_max_len * index;
cb_ret = CallMsprofReport(reporter_data);
GE_IF_BOOL_EXEC(cb_ret != 0, GELOGE(cb_ret, "Reporter data [%s] failed, ret:%d", tag_name.c_str(), cb_ret);
return;);
@ -745,15 +745,32 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool ProfilingManager::Profilin
return execute_model_prof_on;
}
FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ProfilingManager::PluginInit() const {
FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ProfilingManager::PluginInit() {
if (prof_cb_.msprofReporterCallback == nullptr) {
GELOGE(ge::PARAM_INVALID, "MsprofReporterCallback callback is nullptr.");
return ge::PARAM_INVALID;
}
return prof_cb_.msprofReporterCallback(
int32_t cb_ret = prof_cb_.msprofReporterCallback(
static_cast<uint32_t>(MsprofReporterModuleId::MSPROF_MODULE_FRAMEWORK),
static_cast<uint32_t>(MsprofReporterCallbackType::MSPROF_REPORTER_INIT),
nullptr, 0);
if (cb_ret != MSPROF_ERROR_NONE) {
REPORT_CALL_ERROR("E19999", "Profiling reporter init failed, ret = %d.", cb_ret);
GELOGE(INTERNAL_ERROR, "[Init][ProfilingReporter] profiling init failed, ret = %d.", cb_ret);
return INTERNAL_ERROR;
}
cb_ret = prof_cb_.msprofReporterCallback(
static_cast<uint32_t>(MsprofReporterModuleId::MSPROF_MODULE_FRAMEWORK),
static_cast<uint32_t>(MsprofReporterCallbackType::MSPROF_REPORTER_DATA_MAX_LEN),
&reporter_max_len_, sizeof(uint32_t));
if (cb_ret != MSPROF_ERROR_NONE) {
REPORT_CALL_ERROR("E19999", "Get profiling reporter data max len failed, ret = %d.", cb_ret);
GELOGE(INTERNAL_ERROR, "[Init][ProfilingReporter] Get profiling reporter data max len failed, ret = %d.", cb_ret);
return INTERNAL_ERROR;
}
return SUCCESS;
}
FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY void ProfilingManager::PluginUnInit() const {

3
ge/common/profiling/profiling_manager.h
Unescape View File

@ -88,7 +88,7 @@ class FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY ProfilingManager {
void ProfilingTaskDescInfo(uint32_t model_id, const std::vector<TaskDescInfo> &task_desc_info,
const int32_t &device_id);
void ProfilingOpInputOutInfo(const TaskDescInfo &task, Json &task_json);
Status PluginInit() const;
Status PluginInit();
void PluginUnInit() const;
Status CallMsprofReport(ReporterData &reporter_data) const;
struct MsprofCallback &GetMsprofCallback() { return prof_cb_; }
@ -119,6 +119,7 @@ class FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY ProfilingManager {
MsprofCallback prof_cb_;
std::string fp_point_;
std::string bp_point_;
uint32_t reporter_max_len_ = 0;
};
} // namespace ge
#endif // GE_COMMON_PROFILING_PROFILING_MANAGER_H_

40
ge/generator/ge_generator.cc
Unescape View File

@ -154,7 +154,7 @@ static Status CheckEngineTypeSupport(const NodePtr &node, OpEngineType engine_ty
}
static Status AddInputs(const ComputeGraphPtr &graph, const NodePtr &node, const GeTensorDesc &tensor, int32_t index,
bool attr) {
bool attr, int32_t &data_index) {
GE_CHECK_NOTNULL_EXEC(graph, return PARAM_INVALID);
GE_CHECK_NOTNULL_EXEC(node, return PARAM_INVALID);
@ -197,9 +197,10 @@ static Status AddInputs(const ComputeGraphPtr &graph, const NodePtr &node, const
"[Add][InputDesc]fail for node:%s", data_op->GetName().c_str());
GE_CHK_BOOL_EXEC(data_op->AddOutputDesc(tensor) == GRAPH_SUCCESS, return FAILED,
"[Add][OutputDesc]fail for node:%s", data_op->GetName().c_str());
if (attr) {
GE_CHK_BOOL_EXEC(AttrUtils::SetInt(data_op, ATTR_NAME_INDEX, index), return FAILED,
if (attr && !is_const) {
GE_CHK_BOOL_EXEC(AttrUtils::SetInt(data_op, ATTR_NAME_INDEX, data_index), return FAILED,
"[Set][Attr:%s]fail for node:%s", ATTR_NAME_INDEX.c_str(), data_op->GetName().c_str());
++data_index;
}
ge::NodePtr arg_node = graph->AddNode(data_op);
@ -571,7 +572,7 @@ Status GeGenerator::SetModelNameForDump(const GeRootModelPtr &ge_root_model) {
if (ret != SUCCESS) {
GELOGE(FAILED, "[Check][IsUnknownShape]Check root model is unknown shape failed, model id:%u",
ge_root_model->GetModelId());
REPORT_CALL_ERROR("E19999", "Check root model is unknown shape failed, model id:%zu",
REPORT_CALL_ERROR("E19999", "Check root model is unknown shape failed, model id:%u",
ge_root_model->GetModelId());
return FAILED;
}
@ -592,8 +593,6 @@ Status GeGenerator::SetModelNameForDump(const GeRootModelPtr &ge_root_model) {
ErrorManager::GetInstance().ATCReportErrMessage("E10000", {"parameter"}, {"output"});
GELOGE(FAILED, "[Check][GetModelNameStep]Get model_name failed. Param --output is invalid, root graph name: %s",
ge_root_model->GetRootGraph()->GetName().c_str());
REPORT_CALL_ERROR("E19999", "Get model_name failed. Param --output is invalid,",
"root graph name: %s", ge_root_model->GetRootGraph()->GetName().c_str());
return PARAM_INVALID;
}
map<string, GeModelPtr> name_to_ge_model = ge_root_model->GetSubgraphInstanceNameToModel();
@ -709,6 +708,17 @@ bool GeGenerator::CheckNoAicore(const ComputeGraphPtr &graph) {
return true;
}
void GeGenerator::RemoveConst(const vector<GeTensor> &inputs, vector<GeTensor> &outputs) {
for (auto &input : inputs) {
GeTensorDesc input_desc = input.GetTensorDesc();
bool is_const = false;
(void)AttrUtils::GetBool(input_desc, CONST_ATTR_NAME_INPUT, is_const);
if (!is_const) {
outputs.emplace_back(input);
}
}
}
Status GeGenerator::CheckForSingleOp(OpDescPtr &op_desc, const vector<GeTensor> &inputs,
const vector<GeTensor> &outputs) {
GE_CHECK_NOTNULL_EXEC(op_desc, return PARAM_INVALID);
@ -773,7 +783,9 @@ Status GeGenerator::BuildSingleOp(OpDescPtr &op_desc, const vector<GeTensor> &in
GELOGI("ATC parser success in single op build.");
GeRootModelPtr ge_root_model = nullptr;
GE_CHK_STATUS_RET_NOLOG(impl_->BuildModel(graph, inputs, ge_root_model));
vector<GeTensor> data_inputs;
RemoveConst(inputs, data_inputs);
GE_CHK_STATUS_RET_NOLOG(impl_->BuildModel(graph, data_inputs, ge_root_model));
map<string, GeAttrValue> op_attrs = op_desc_tmp->GetAllAttrs();
GE_CHECK_NOTNULL(ge_root_model);
GE_CHECK_NOTNULL(ge_root_model->GetRootGraph());
@ -832,9 +844,12 @@ Status GeGenerator::BuildSingleOpModel(OpDescPtr &op_desc, const vector<GeTensor
* @param [in] vector<GeTensor> &inputs: Operator input data description information.
* @param [in] vector<GeTensor> &outputs: Operator output data description information.
* @param [in] engine_type: specific engine.
* @param [in] compile_flag: op build flag, compile flag by acl
* @param [out] ModelBufferData &Model_buff: Model_buff: model buffer of the op.
* @return SUCCESS handle successfully / others handle failed
*/
// old process will be deleted
Status GeGenerator::BuildSingleOpModel(OpDescPtr &op_desc, const vector<GeTensor> &inputs,
const vector<GeTensor> &outputs, OpEngineType engine_type,
ModelBufferData &model_buff) {
@ -845,6 +860,12 @@ Status GeGenerator::BuildSingleOpModel(OpDescPtr &op_desc, const vector<GeTensor
return status;
}
Status GeGenerator::BuildSingleOpModel(OpDescPtr &op_desc, const vector<GeTensor> &inputs,
const vector<GeTensor> &outputs, OpEngineType engine_type, int32_t compile_flag,
ModelBufferData &model_buff) {
return SUCCESS;
}
Status GeGenerator::BuildSingleOpGraph(OpDescPtr &op_desc, const vector<GeTensor> &inputs,
const vector<GeTensor> &outputs, std::string graph_name, Graph &graph) {
ge::ComputeGraphPtr compute_graph = MakeShared<ComputeGraph>(graph_name);
@ -856,18 +877,19 @@ Status GeGenerator::BuildSingleOpGraph(OpDescPtr &op_desc, const vector<GeTensor
// 2. Create InputData node.
int32_t arg_index = 0;
int32_t data_index = 0;
if (inputs.empty()) {
for (const auto &input_desc : op_desc->GetAllInputsDescPtr()) {
GE_CHECK_NOTNULL_EXEC(input_desc, return INTERNAL_ERROR);
if (!IsNeedConnectInputOpForSingleOp(*input_desc)) {
continue;
}
GE_CHK_STATUS_RET_NOLOG(AddInputs(compute_graph, op_node, *input_desc, arg_index, false));
GE_CHK_STATUS_RET_NOLOG(AddInputs(compute_graph, op_node, *input_desc, arg_index, false, data_index));
arg_index++;
}
} else {
for (const auto &in_desc : inputs) {
GE_CHK_STATUS_RET_NOLOG(AddInputs(compute_graph, op_node, in_desc.GetTensorDesc(), arg_index, true));
GE_CHK_STATUS_RET_NOLOG(AddInputs(compute_graph, op_node, in_desc.GetTensorDesc(), arg_index, true, data_index));
arg_index++;
}
}

37
ge/graph/build/graph_builder.cc
Unescape View File

@ -77,6 +77,8 @@ Status HandleSubgraphNode(NodePtr &src_node, OutDataAnchorPtr &src_out_anchor) {
Status HandleSubgraphDataNode(NodePtr &src_node, OutDataAnchorPtr &src_out_anchor) {
uint32_t index = 0;
if (!AttrUtils::GetInt(src_node->GetOpDesc(), ATTR_NAME_PARENT_NODE_INDEX, index)) {
REPORT_INNER_ERROR("E19999", "get attr:%s failed from node:%s when HandleSubgraphDataNode",
ATTR_NAME_PARENT_NODE_INDEX.c_str(), src_node->GetName().c_str());
GELOGE(FAILED, "Get attr ATTR_NAME_PARENT_NODE_INDEX failed, node:%s.", src_node->GetName().c_str());
return FAILED;
}
@ -109,6 +111,8 @@ Status GraphBuilder::CalcOpParam(const ge::ComputeGraphPtr &graph) {
GE_CHECK_NOTNULL(graph);
auto instance_ptr = ge::GELib::GetInstance();
if (instance_ptr == nullptr || !instance_ptr->InitFlag()) {
REPORT_INNER_ERROR("E19999", "check gelib instance null when CalcOpParam for graph:%s",
graph->GetName().c_str());
GELOGE(GE_CLI_GE_NOT_INITIALIZED, "GraphBuilder: GE is not initialized");
return GE_CLI_GE_NOT_INITIALIZED;
}
@ -121,6 +125,8 @@ Status GraphBuilder::CalcOpParam(const ge::ComputeGraphPtr &graph) {
(void)instance_ptr->DNNEngineManagerObj().GetDNNEngineName(node_ptr);
kernel_lib_name = node_ptr->GetOpDesc()->GetOpKernelLibName();
if (kernel_lib_name.empty()) {
REPORT_INNER_ERROR("E19999", "op kernel lib is empty in node:%s(%s) when CalcOpParam",
node_ptr->GetName().c_str(), node_ptr->GetType().c_str());
GELOGE(INTERNAL_ERROR, "Get node:%s(%s) kernel lib failed.", node_ptr->GetName().c_str(),
node_ptr->GetType().c_str());
return INTERNAL_ERROR;
@ -129,12 +135,16 @@ Status GraphBuilder::CalcOpParam(const ge::ComputeGraphPtr &graph) {
auto ret = SetInputSize(node_ptr);
if (ret != SUCCESS) {
REPORT_CALL_ERROR("E19999", "Set node:%s(%s) inputDesc size failed when CalcOpParam",
node_ptr->GetName().c_str(), node_ptr->GetType().c_str());
GELOGE(ret, "Set node inputDesc size failed, node name is %s", node_ptr->GetName().c_str());
return ret;
}
ret = OpsKernelBuilderManager::Instance().CalcOpRunningParam(*node_ptr);
if (ret != SUCCESS) {
REPORT_CALL_ERROR("E19999", "Call Calculate op:%s(%s) running param failed",
node_ptr->GetName().c_str(), node_ptr->GetType().c_str());
GELOGE(ret, "Calculate op running param failed, node name is %s", node_ptr->GetName().c_str());
return ret;
}
@ -191,6 +201,7 @@ Status GraphBuilder::UpdateParentNodeOutputSize(const ge::ComputeGraphPtr &graph
Status GraphBuilder::Build(ComputeGraphPtr &comp_graph, GeRootModelPtr &ge_root_model_ptr, uint64_t session_id) {
if (comp_graph == nullptr) {
REPORT_INNER_ERROR("E19999", "check compute_graph nullptr when BuildGraph, session_id:%lu", session_id);
GELOGE(GE_GRAPH_PARAM_NULLPTR, "Graph build comp_graph is null.");
return GE_GRAPH_PARAM_NULLPTR;
}
@ -302,6 +313,8 @@ Status GraphBuilder::SetConstantInputOffset(ComputeGraphPtr &comp_graph) {
std::vector<GeTensorPtr> weights = OpDescUtils::MutableWeights(peer_node);
if (weights.empty()) {
REPORT_INNER_ERROR("E19999", "check weights size of node %s(%s) is empty when SetConstantInputOffset",
node->GetName().c_str(), node->GetType().c_str());
GELOGE(FAILED, "weights size of node %s is empty", node->GetName().c_str());
return FAILED;
}
@ -393,6 +406,7 @@ static Status InsertMemcpyNode(const ComputeGraphPtr &graph, const OutDataAnchor
.Build();
(void)AttrUtils::SetBool(op_desc, ATTR_NO_NEED_CONSTANT_FOLDING, false);
if (GraphUtils::InsertNodeAfter(out_anchor, in_anchors, graph->AddNode(op_desc)) != GRAPH_SUCCESS) {
REPORT_CALL_ERROR("E19999", "Insert IDENTITY node %s after %s failed", name.c_str(), in_node->GetName().c_str());
GELOGE(FAILED, "Insert IDENTITY node %s after %s failed.", name.c_str(), in_node->GetName().c_str());
return FAILED;
}
@ -423,6 +437,8 @@ static Status GenerateTaskForConstant(const std::shared_ptr<ComputeGraph> &graph
GELOGD("Insert MemcpyAsync node between %s and %s.", in_node->GetName().c_str(), node->GetName().c_str());
std::string name = node->GetName() + "_input_" + std::to_string(in_data_anchor->GetIdx()) + "_Memcpy";
if (InsertMemcpyNode(graph, peer_out_anchor, {in_data_anchor}, name) != SUCCESS) {
REPORT_CALL_ERROR("E19999", "Insert memcpy between %s and %s failed when GenerateTaskForConstant",
in_node->GetName().c_str(), node->GetName().c_str());
GELOGE(FAILED, "Insert memcpy between %s and %s failed.",
in_node->GetName().c_str(), node->GetName().c_str());
return FAILED;
@ -470,6 +486,8 @@ Status GraphBuilder::MarkFpBpProfilingTaskAttr(ComputeGraphPtr &com_graph) {
GELOGI("The all reduce node of dynamic graph is %s, idx %u", op_desc->GetName().c_str(), node_index);
(void)ge::AttrUtils::SetBool(op_desc, ATTR_NAME_INSERT_BP_PROFILILNG_TASK, true);
GE_IF_BOOL_EXEC(TypeUtils::CheckUint64MulOverflow(i, kProfilingArStep),
REPORT_INNER_ERROR("E19999", "Multiply result is out of range when calc profiling ar log id "
"for node:%s(%s)", op_desc->GetName().c_str(), op_desc->GetType().c_str());
GELOGE(FAILED, "Multiply result is out of range.");
return FAILED);
int64_t log_id = i * kProfilingArStep + kProfilingArStartLogid;
@ -549,16 +567,19 @@ Status GraphBuilder::GetTaskInfo(const ge::ModelBuilder &builder, const ModelPtr
int64_t memory_size = 0;
if (!AttrUtils::GetInt(model_ptr, ATTR_MODEL_MEMORY_SIZE, memory_size)) {
REPORT_INNER_ERROR("E19999", "Get Attr:%s fail in model", ATTR_MODEL_MEMORY_SIZE.c_str());
GELOGE(INTERNAL_ERROR, "Get memory size fail.");
return INTERNAL_ERROR;
}
int64_t p2p_memory_size = 0;
if (!AttrUtils::GetInt(model_ptr, ATTR_MODEL_P2P_MEMORY_SIZE, p2p_memory_size)) {
REPORT_INNER_ERROR("E19999", "Get Attr:%s fail in model", ATTR_MODEL_P2P_MEMORY_SIZE.c_str());
GELOGE(INTERNAL_ERROR, "Get p2p memory size fail.");
return INTERNAL_ERROR;
}
int64_t weight_size = 0;
if (!AttrUtils::GetInt(model_ptr, ATTR_MODEL_WEIGHT_SIZE, weight_size)) {
REPORT_INNER_ERROR("E19999", "Get Attr:%s fail in model", ATTR_MODEL_WEIGHT_SIZE.c_str());
GELOGE(INTERNAL_ERROR, "Get weight memory size fail.");
return INTERNAL_ERROR;
}
@ -668,6 +689,7 @@ Status GraphBuilder::SetInputSize(const ge::NodePtr &node_ptr) {
Status GraphBuilder::UpdateDataInputSize(const ge::NodePtr &node_ptr) {
const auto &op_desc = node_ptr->GetOpDesc();
if (op_desc == nullptr) {
REPORT_INNER_ERROR("E19999", "check op_desc is nullptr when UpdateDataInputSize");
GELOGE(FAILED, "Op desc is nullptr.");
return FAILED;
}
@ -685,6 +707,8 @@ Status GraphBuilder::UpdateDataInputSize(const ge::NodePtr &node_ptr) {
int64_t real_dim_size = 0;
ge::graphStatus graph_status = TensorUtils::GetTensorSizeInBytes(output_desc, real_dim_size);
if (graph_status != GRAPH_SUCCESS) {
REPORT_CALL_ERROR("E19999", "Get tensor size in bytes failed for op:%s(%s) index:0 when UpdateDataInputSize",
op_desc->GetName().c_str(), op_desc->GetType().c_str());
GELOGE(FAILED, "Get tensor size in bytes failed.");
return FAILED;
}
@ -692,6 +716,8 @@ Status GraphBuilder::UpdateDataInputSize(const ge::NodePtr &node_ptr) {
ge::GeTensorDesc input_desc = op_desc->GetInputDesc(0);
ge::TensorUtils::SetSize(input_desc, real_dim_size);
if (op_desc->UpdateInputDesc(0, input_desc) != GRAPH_SUCCESS) {
REPORT_CALL_ERROR("E19999", "Update input desc size failed for op:%s(%s) index:0 when UpdateDataInputSize",
op_desc->GetName().c_str(), op_desc->GetType().c_str());
GELOGE(FAILED, "Update input desc size failed.");
return FAILED;
}
@ -720,6 +746,9 @@ Status GraphBuilder::CalcDynShapeRootGraphDataSize(const ge::OpDescPtr &op_desc)
int64_t real_dim_size = 0;
ge::graphStatus graph_status = TensorUtils::GetTensorSizeInBytes(output_desc, real_dim_size);
if (graph_status != GRAPH_SUCCESS) {
REPORT_CALL_ERROR("E19999", "Get tensor size in bytes failed for op:%s(%s) index:0 "
"when CalcDynShapeRootGraphDataSize",
op_desc->GetName().c_str(), op_desc->GetType().c_str());
GELOGE(FAILED, "Get tensor size in bytes failed.");
return FAILED;
}
@ -727,6 +756,9 @@ Status GraphBuilder::CalcDynShapeRootGraphDataSize(const ge::OpDescPtr &op_desc)
ge::TensorUtils::SetSize(output_desc, real_dim_size);
GELOGI("Update dynamic shape graph data output size to [%ld].", real_dim_size);
if (op_desc->UpdateOutputDesc(0, output_desc) != GRAPH_SUCCESS) {
REPORT_CALL_ERROR("E19999", "Update output desc size failed for op:%s(%s) index:0 "
"when CalcDynShapeRootGraphDataSize",
op_desc->GetName().c_str(), op_desc->GetType().c_str());
GELOGE(FAILED, "Update dynamic shape graph data output desc size failed.");
return FAILED;
}
@ -744,6 +776,8 @@ Status GraphBuilder::SecondPartition(ge::ComputeGraphPtr &comp_graph) {
GE_CHK_STATUS_RET(ret, "Graph partition Failed.");
const auto &graph_2_subgraphlist = graph_partitioner_.GetSubGraphMap();
if (graph_2_subgraphlist.find(comp_graph) == graph_2_subgraphlist.end()) {
REPORT_INNER_ERROR("E19999", "find subgraphlis in graph:%s failed when SecondPartition",
comp_graph->GetName().c_str());
GELOGE(FAILED, "Find subgraph failed.");
return FAILED;
}
@ -772,6 +806,9 @@ Status GraphBuilder::AddOutputMemTypeForNode(const NodePtr &node) {
mem_type);
if (!AttrUtils::SetInt(src_desc->MutableOutputDesc(src_out_anchor->GetIdx()), ATTR_OUTPUT_MEMORY_TYPE,
mem_type)) {
REPORT_INNER_ERROR("E19999", "Set Attr:%s for node:%s(%s) out_index:%u failed when AddOutputMemTypeForNode",
ATTR_OUTPUT_MEMORY_TYPE.c_str(), src_desc->GetName().c_str(), src_desc->GetType().c_str(),
src_out_anchor->GetIdx());
GELOGE(INTERNAL_ERROR, "Set out_memory_type attr for [%s:%d] failed.", src_desc->GetName().c_str(),
src_out_anchor->GetIdx());
return INTERNAL_ERROR;

10
ge/graph/build/label_allocator.cc
Unescape View File

@ -28,6 +28,7 @@ LabelAllocator::LabelAllocator(const ComputeGraphPtr &graph) : compute_graph_(gr
Status LabelAllocator::AssignFunctionalLabels() {
if (compute_graph_ == nullptr) {
REPORT_INNER_ERROR("E19999", "check param compute_graph nullptr when AssignFunctionalLabels");
GELOGE(INTERNAL_ERROR, "ComputeGraph not set, Assign labels failed.");
return INTERNAL_ERROR;
}
@ -46,11 +47,15 @@ Status LabelAllocator::AssignFunctionalLabels() {
for (auto node : functional_nodes) {
LabelMakerPtr maker = LabelMakerFactory::Instance().Create(node->GetType(), compute_graph_, node);
if (maker == nullptr) {
REPORT_CALL_ERROR("E19999", "Check Node:%s(%s) label maker not registed when AssignFunctionalLabels",
node->GetName().c_str(), node->GetType().c_str());
GELOGE(INTERNAL_ERROR, "Node: %s label maker not registed.", node->GetType().c_str());
return INTERNAL_ERROR;
}
if (maker->Run(label_index) != SUCCESS) {
REPORT_CALL_ERROR("E19999", "Node:%s(%s) run label maker failed when AssignFunctionalLabels",
node->GetName().c_str(), node->GetType().c_str());
GELOGE(INTERNAL_ERROR, "Node: %s run label maker failed.", node->GetType().c_str());
return INTERNAL_ERROR;
}
@ -63,6 +68,7 @@ Status LabelAllocator::AssignFunctionalLabels() {
bool LabelAllocator::CollectFunctionalNode(ComputeGraphPtr &graph, std::set<NodePtr> &functional_nodes) {
if (graph == nullptr) {
REPORT_INNER_ERROR("E19999", "check param compute_graph nullptr when CollectFunctionalNode");
GELOGE(INTERNAL_ERROR, "Sub ComputeGraph is null.");
return false;
}
@ -74,12 +80,16 @@ 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());
GELOGE(INTERNAL_ERROR, "Parent functional node not set: %s.", graph->GetName().c_str());
return false;
}
ComputeGraphPtr owner_graph = func_node->GetOwnerComputeGraph();
if (owner_graph == nullptr) {
REPORT_INNER_ERROR("E19999", "ComputeGraph owner not set in node:%s(%s), graph:%s",
func_node->GetName().c_str(), func_node->GetType().c_str(), graph->GetName().c_str());
GELOGE(INTERNAL_ERROR, "ComputeGraph owner not set: %s.", func_node->GetName().c_str());
return false;
}

9
ge/graph/build/logical_stream_allocator.cc
Unescape View File

@ -320,6 +320,8 @@ Status SingleStreamPass::Run(ComputeGraphPtr graph, const vector<SubgraphPtr> &s
if (!HasAssignedStream(*subgraph)) {
const string &stream_label = subgraph->subgraph_info.GetStreamLabel();
if (!stream_label.empty()) {
REPORT_INNER_ERROR("E19999", "Stream labels are not supported in SingleStream mode "
"(subgraph: %s, stream label: %s)", subgraph->name.c_str(), stream_label.c_str());
GELOGE(INTERNAL_ERROR, "Stream labels are not supported (subgraph: %s, stream label: %s).",
subgraph->name.c_str(), stream_label.c_str());
return INTERNAL_ERROR;
@ -337,6 +339,8 @@ Status NodeStreamUpdatePass::Run(ComputeGraphPtr graph, const vector<SubgraphPtr
const string &engine_name = subgraph->engine_conf.id;
if (!IsEngineSkip(*subgraph) && !HasAssignedStream(*subgraph)) {
REPORT_INNER_ERROR("E19999", "Subgraph %s has not yet been assigned a stream (engine: %s) "
" when run NodeStreamUpdatePass", subgraph->name.c_str(), engine_name.c_str());
GELOGE(INTERNAL_ERROR, "Subgraph %s has not yet been assigned a stream (engine: %s).", subgraph->name.c_str(),
engine_name.c_str());
return INTERNAL_ERROR;
@ -636,6 +640,8 @@ Status LogicalStreamAllocator::DoAssign(const ComputeGraphPtr &graph, const Grap
auto iter = subgraph_map.find(graph);
if (iter == subgraph_map.end()) {
REPORT_INNER_ERROR("E19999", "Graph %s not found in subgraph_map when do logical stream assign ",
graph->GetName().c_str());
GELOGE(FAILED, "Graph %s not found.", graph->GetName().c_str());
return FAILED;
}
@ -675,6 +681,8 @@ Status LogicalStreamAllocator::ConvertSubgraphs(const vector<SubGraphInfoPtr> &s
const string &engine_name = subgraph_info->GetEngineName();
auto engine_conf_iter = engine_confs.find(engine_name);
if ((engine_conf_iter == engine_confs.end()) || (engine_conf_iter->second == nullptr)) {
REPORT_INNER_ERROR("E19999", "Engine conf of subgraph %s not found (engine name: %s) when ConvertSubgraphs",
subgraph_name.c_str(), engine_name.c_str());
GELOGE(INTERNAL_ERROR, "Engine conf of subgraph %s not found (engine name: %s).", subgraph_name.c_str(),
engine_name.c_str());
@ -722,6 +730,7 @@ Status LogicalStreamAllocator::RunPasses(const ComputeGraphPtr &graph, const vec
} else if (status == NOT_CHANGED) {
GELOGD("[Show][Status]Stream pass %s return NOT_CHANGED.", pass->GetName().c_str());
} else {
REPORT_CALL_ERROR("E19999", "Stream pass %s run failed.", pass->GetName().c_str());
GELOGE(status, "Stream pass %s failed.", pass->GetName().c_str());
return status;
}

11
ge/graph/build/memory/block_mem_assigner.cc
Unescape View File

@ -430,17 +430,14 @@ void SetLastUsedInputMemAttr(NodePtr &node, int input_index) {
}
auto node_op_desc = node->GetOpDesc();
if (node_op_desc != nullptr) {
auto input_desc = node_op_desc->GetInputDesc(input_index);
if (!ge::AttrUtils::SetInt(input_desc, ATTR_NAME_IS_END_OF_INPUTMEM_LIFECYCLE, true)) {
auto input_desc = node_op_desc->MutableInputDesc(input_index);
if (!ge::AttrUtils::SetInt(*input_desc, ATTR_NAME_IS_END_OF_INPUTMEM_LIFECYCLE, true)) {
GELOGW("Set %s input[%d] ATTR_NAME_IS_END_OF_INPUTMEM_LIFECYCLE to true failed.", node_op_desc->GetName().c_str(),
input_index);
return;
}
GELOGD("Set %s input[%d] ATTR_NAME_IS_END_OF_INPUTMEM_LIFECYCLE to true success.", node_op_desc->GetName().c_str(),
input_index);
if (node_op_desc->UpdateInputDesc(input_index, input_desc) != GRAPH_SUCCESS) {
GELOGW("Update %s input[%d] desc failed.", node_op_desc->GetName().c_str(), input_index);
}
}
}
@ -593,9 +590,9 @@ void BlockMemAssigner::GetOutAndWorkSpaceMem(vector<int64_t> &all_memory_size) {
}
for (auto &out_anchor : n->GetAllOutDataAnchors()) {
GeTensorDesc output_desc = node_op_desc->GetOutputDesc(out_anchor->GetIdx());
auto output_desc = node_op_desc->GetOutputDescPtr(out_anchor->GetIdx());
int64_t size = 0;
GE_IF_BOOL_EXEC(ge::TensorUtils::GetSize(output_desc, size) != SUCCESS, GELOGI("Get size failed"));
GE_IF_BOOL_EXEC(ge::TensorUtils::GetSize(*output_desc, size) != SUCCESS, GELOGI("Get size failed"));
GE_IF_BOOL_EXEC(size < 0,
GELOGE(FAILED, "[Check][TensorSize]tensor_size:%ld is invalid, "
"maybe it is unknown shape node, Node_name:%s",

3
ge/graph/build/memory/graph_mem_assigner.cc
Unescape View File

@ -482,7 +482,7 @@ Status GraphMemoryAssigner::ReAssignContinuousMemory(bool is_loop_graph) {
"[Assign][Memory:Continuous:Input]fail for node:%s.", node->GetName().c_str())
}
for (auto pair : memory_offset_) {
GELOGD("[Reassign][Memory:Continuous]At last, memory type = %ld, mem offset = %zu.", pair.first,
GELOGD("[Reassign][Memory:Continuous]At last, memory type = %ld, mem offset = %zu", pair.first,
pair.second.mem_offset_);
}
return ge::SUCCESS;
@ -1215,6 +1215,7 @@ Status GraphMemoryAssigner::CheckOffset() {
std::map<std::string, std::string> anchor_to_symbol;
std::map<std::string, std::list<NodeIndexIO>> symbol_to_anchors;
if (GraphUtils::GetRefMapping(compute_graph_, symbol_to_anchors, anchor_to_symbol) != GRAPH_SUCCESS) {
REPORT_CALL_ERROR("E19999", "Get ref-mapping for graph %s failed", compute_graph_->GetName().c_str());
GELOGE(FAILED, "[Get][RefMapping]fail for graph %s", compute_graph_->GetName().c_str());
return FAILED;
}

1
ge/graph/build/memory/hybrid_mem_assigner.cc
Unescape View File

@ -42,6 +42,7 @@ Status HybridMemAssigner::AssignMemory(std::unique_ptr<BlockMemAssigner> &block_
Status HybridMemAssigner::Assign() {
if (GraphUtils::GetRefMapping(compute_graph_, symbol_to_anchors_, anchor_to_symbol_) != GRAPH_SUCCESS) {
REPORT_CALL_ERROR("E19999", "Get ref-mapping for graph %s failed", compute_graph_->GetName().c_str());
GELOGE(FAILED, "Get ref-mapping for graph %s failed.", compute_graph_->GetName().c_str());
return FAILED;
}

21
ge/graph/build/memory/var_mem_assign_util.cc
Unescape View File

@ -53,6 +53,8 @@ Status VarMemAssignUtil::AssignStaticMemory2Node(ge::ComputeGraphPtr &compute_gr
GE_IF_BOOL_EXEC(ge::AttrUtils::GetStr(n->GetOpDesc(), REF_VAR_SRC_VAR_NAME, ref_var_src_var_name), continue);
string node_name = n->GetName();
GE_IF_BOOL_EXEC(n->GetOpDesc()->GetAllOutputsDesc().empty(),
REPORT_INNER_ERROR("E19999", "check node:%s has no OutputDesc when AssignStaticMemory2Node",
n->GetName().c_str());
GELOGE(FAILED, "node:%s has no OutputDesc.", n->GetName().c_str());
return FAILED);
ge::ConstGeTensorDescPtr tensor_desc = n->GetOpDesc()->GetOutputDescPtr(0);
@ -116,6 +118,8 @@ Status VarMemAssignUtil::SetOutVariableAttr(const ge::NodePtr &node, const ge::N
GE_CHECK_NOTNULL(node->GetOpDesc());
output_list = node->GetOpDesc()->GetOutputOffset();
if (output_list.empty()) {
REPORT_INNER_ERROR("E19999", "check node:%s output_offset_list is empty when SetOutVariableAttr",
node->GetName().c_str());
GELOGE(PARAM_INVALID, "Output_list is empty");
return PARAM_INVALID;
}
@ -126,7 +130,12 @@ Status VarMemAssignUtil::SetOutVariableAttr(const ge::NodePtr &node, const ge::N
VarManager::Instance(session_id)->GetVarAddr(var_node->GetName(), var_tensor_desc, &dev_ptr, memory_type));
int out_list_size = static_cast<int>(output_list.size());
GE_CHK_BOOL_RET_STATUS(index < out_list_size, FAILED, "index %d >= output_list.size() %d", index, out_list_size);
if (index >= out_list_size) {
REPORT_INNER_ERROR("E19999", "param index:%d >= output_list.size() %d in node %s, "
"check invalid when SetOutVariableAttr", index, out_list_size, node->GetName().c_str());
GELOGE(FAILED, "index %d >= output_list.size() %d", index, out_list_size);
return FAILED;
}
output_list[index] = static_cast<int64_t>(reinterpret_cast<intptr_t>(dev_ptr));
GELOGI("Assign node outputOffset[index] is: %ld", output_list[index]);
@ -168,9 +177,13 @@ Status VarMemAssignUtil::DealBroadCastNode(uint32_t graph_id, const ge::NodePtr
auto broad_cast_index = static_cast<size_t>(broad_cast_info.idx);
auto input_tensor_desc_ptr_vistor = op_desc->GetAllInputsDescPtr();
GE_CHK_BOOL_RET_STATUS(input_tensor_desc_ptr_vistor.size() > broad_cast_index, FAILED,
"Get broadcast op %s input tensor desc size [%zu] < idx [%d]", node->GetName().c_str(),
input_tensor_desc_ptr_vistor.size(), broad_cast_info.idx);
if (input_tensor_desc_ptr_vistor.size() <= broad_cast_index) {
REPORT_INNER_ERROR("E19999", "Get broadcast op %s input tensor desc size [%zu] < idx [%d]",
node->GetName().c_str(), input_tensor_desc_ptr_vistor.size(), broad_cast_info.idx);
GELOGE(FAILED, "Get broadcast op %s input tensor desc size [%zu] < idx [%d]", node->GetName().c_str(),
input_tensor_desc_ptr_vistor.size(), broad_cast_info.idx);
return FAILED;
}
const ge::GeTensorDescPtr input_tensor_desc =
input_tensor_desc_ptr_vistor.at(static_cast<size_t>(broad_cast_info.idx));
int64_t input_size = 0;

72
ge/graph/build/model_builder.cc
Unescape View File

@ -116,11 +116,15 @@ Status ModelBuilder::CalcOutputSize(const ge::NodePtr &n) {
int64_t size_temp = 0;
graphStatus graph_status = TensorUtils::GetTensorMemorySizeInBytes(desc_temp, size_temp);
if (graph_status != GRAPH_SUCCESS) {
REPORT_CALL_ERROR("E19999", "Get tensor size in bytes failed for op:%s(%s) index:%u when CalcOutputSize",
node_op_desc->GetName().c_str(), node_op_desc->GetType().c_str(), index);
GELOGE(graph_status, "GetTensorMemorySizeInBytes failed!");
return FAILED;
}
TensorUtils::SetSize(desc_temp, size_temp);
if (node_op_desc->UpdateOutputDesc(index, desc_temp) != SUCCESS) {
REPORT_CALL_ERROR("E19999", "Update Output desc size failed for op:%s(%s) index:%u when CalcOutputSize",
node_op_desc->GetName().c_str(), node_op_desc->GetType().c_str(), index);
GELOGE(FAILED, "UpdateOutputDesc failed.");
return FAILED;
}
@ -197,8 +201,7 @@ void ModelBuilder::SetInputIsConst(const ge::NodePtr &n) {
}
}
std::string input_const_info = ToString(is_input_const);
GELOGD("update opdesc:%s InputConst:%s", node_op_desc->GetName().c_str(), input_const_info.c_str());
GELOGD("update opdesc:%s InputConst:%s", node_op_desc->GetName().c_str(), ToString(is_input_const).c_str());
node_op_desc->SetIsInputConst(is_input_const);
}
@ -207,11 +210,15 @@ Status ModelBuilder::AdjustConstWeightSize(const ge::NodePtr &node, size_t &mem_
if (node->GetType() == CONSTANT) {
vector<GeTensorPtr> weights = OpDescUtils::MutableWeights(node);
if (weights.empty()) {
REPORT_INNER_ERROR("E19999", "Check weights size of node %s(%s) is empty when AdjustConstWeightSize",
node->GetName().c_str(), node->GetType().c_str());
GELOGE(FAILED, "weights size of node %s is empty", node->GetName().c_str());
return FAILED;
}
GeTensorPtr weight = weights[0];
if (weight == nullptr) {
REPORT_INNER_ERROR("E19999", "Check weight of node %s(%s) is nullptr when AdjustConstWeightSize",
node->GetName().c_str(), node->GetType().c_str());
GELOGE(FAILED, "weights[0] is null.");
return FAILED;
}
@ -353,6 +360,9 @@ Status ModelBuilder::AdjustInputTensorFlag() {
auto input_desc = owner_node_op_desc->GetInputDesc(in_anchors->GetIdx());
ge::TensorUtils::SetInputTensor(input_desc, true);
if (owner_node_op_desc->UpdateInputDesc(in_anchors->GetIdx(), input_desc) != SUCCESS) {
REPORT_CALL_ERROR("E19999", "Update Input desc size failed for op:%s(%s) index:%u when %s",
owner_node_op_desc->GetName().c_str(), owner_node_op_desc->GetType().c_str(),
in_anchors->GetIdx(), __FUNCTION__);
GELOGE(FAILED, "UpdateOutputDesc failed.");
return FAILED;
}
@ -381,33 +391,51 @@ Status ModelBuilder::BuildModelDef(ge::Model &model) {
max_mem_offset_ = mem_type_to_mem_offset_[RT_MEMORY_HBM];
GE_CHK_BOOL_EXEC(ge::AttrUtils::SetInt(&model, ATTR_MODEL_MEMORY_SIZE, max_mem_offset_),
REPORT_INNER_ERROR("E19999", "Set Attr:%s in model failed when %s",
ATTR_MODEL_MEMORY_SIZE.c_str(), __FUNCTION__);
GELOGE(FAILED, "SetInt of ATTR_MODEL_MEMORY_SIZE failed.");
return FAILED);
if (mem_type_to_mem_offset_.find(RT_MEMORY_P2P_DDR) != mem_type_to_mem_offset_.end()) {
p2p_mem_offset_ = mem_type_to_mem_offset_[RT_MEMORY_P2P_DDR];
}
GE_CHK_BOOL_EXEC(ge::AttrUtils::SetInt(&model, ATTR_MODEL_P2P_MEMORY_SIZE, p2p_mem_offset_),
REPORT_INNER_ERROR("E19999", "Set Attr:%s in model failed when %s",
ATTR_MODEL_P2P_MEMORY_SIZE.c_str(), __FUNCTION__);
GELOGE(FAILED, "SetInt of ATTR_MODEL_P2P_MEMORY_SIZE failed.");
return FAILED);
GE_CHK_BOOL_EXEC(ge::AttrUtils::SetInt(&model, ATTR_MODEL_WEIGHT_SIZE, weight_offset_),
REPORT_INNER_ERROR("E19999", "Set Attr:%s in model failed when %s",
ATTR_MODEL_WEIGHT_SIZE.c_str(), __FUNCTION__);
GELOGE(FAILED, "SetInt of ATTR_MODEL_WEIGHT_SIZE failed.");
return FAILED);
GE_CHK_BOOL_EXEC(ge::AttrUtils::SetInt(&model, ATTR_MODEL_STREAM_NUM, stream_num_),
REPORT_INNER_ERROR("E19999", "Set Attr:%s in model failed when %s",
ATTR_MODEL_STREAM_NUM.c_str(), __FUNCTION__);
GELOGE(FAILED, "SetInt of ATTR_MODEL_STREAM_NUM failed.");
return FAILED);
GE_CHK_BOOL_EXEC(ge::AttrUtils::SetInt(&model, ATTR_MODEL_EVENT_NUM, event_num_),
REPORT_INNER_ERROR("E19999", "Set Attr:%s in model failed when %s",
ATTR_MODEL_EVENT_NUM.c_str(), __FUNCTION__);
GELOGE(FAILED, "SetInt of ATTR_MODEL_EVENT_NUM failed.");
return FAILED);
GE_CHK_BOOL_EXEC(ge::AttrUtils::SetListInt(&model, ATTR_MODEL_HUGE_STREAM_LIST, huge_streams_),
REPORT_INNER_ERROR("E19999", "Set Attr:%s in model failed when %s",
ATTR_MODEL_HUGE_STREAM_LIST.c_str(), __FUNCTION__);
GELOGE(FAILED, "SetInt of ATTR_MODEL_HUGE_STREAM_LIST failed.");
return FAILED);
GE_CHK_BOOL_EXEC(ge::AttrUtils::SetInt(&model, ATTR_MODEL_LABEL_NUM, label_num_),
REPORT_INNER_ERROR("E19999", "Set Attr:%s in model failed when %s",
ATTR_MODEL_LABEL_NUM.c_str(), __FUNCTION__);
GELOGE(FAILED, "SetInt of ATTR_MODEL_LABEL_NUM failed.");
return FAILED);
GE_CHK_BOOL_EXEC(ge::AttrUtils::SetInt(&model, ATTR_MODEL_ZERO_COPY_MEMORY_SIZE, zero_copy_mem_size_),
REPORT_INNER_ERROR("E19999", "Set Attr:%s in model failed when %s",
ATTR_MODEL_ZERO_COPY_MEMORY_SIZE.c_str(), __FUNCTION__);
GELOGE(FAILED, "SetInt of ATTR_MODEL_ZERO_COPY_MEMORY_SIZE failed.");
return FAILED);
GE_CHK_BOOL_EXEC(ge::AttrUtils::SetListStr(&model, ATTR_MODEL_OUT_NODES_NAME, GetLocalOmgContext().net_out_nodes),
REPORT_INNER_ERROR("E19999", "Set Attr:%s in model failed when %s",
ATTR_MODEL_OUT_NODES_NAME.c_str(), __FUNCTION__);
GELOGE(FAILED, "SetListStr of ATTR_MODEL_OUT_NODES_NAME failed.");
return FAILED);
GELOGI("For model, max_mem_offset_: %zu, p2p_mem_size: %zu, zero_copy_mem_size_: %zu", max_mem_offset_,
@ -415,6 +443,8 @@ Status ModelBuilder::BuildModelDef(ge::Model &model) {
string fp_ceiling_mode;
if (ge::GetContext().GetOption("ge.fpCeilingMode", fp_ceiling_mode) == SUCCESS) {
if (!ge::AttrUtils::SetStr(&model, ATTR_FP_CEILING_MODE, fp_ceiling_mode)) {
REPORT_INNER_ERROR("E19999", "Set Attr:%s in model failed when %s",
ATTR_FP_CEILING_MODE.c_str(), __FUNCTION__);
GELOGE(FAILED, "Failed to set attr ATTR_FP_CEILING_MODE");
return FAILED;
}
@ -429,22 +459,30 @@ Status ModelBuilder::BuildModelDef(ge::Model &model) {
int64_t core_type = (ge_core_type == kVectorCore) ? 1 : 0;
GELOGI("core_type: %ld", core_type);
if (!ge::AttrUtils::SetInt(&model, ATTR_MODEL_CORE_TYPE, core_type)) {
REPORT_INNER_ERROR("E19999", "Set Attr:%s in model failed when %s",
ATTR_MODEL_CORE_TYPE.c_str(), __FUNCTION__);
GELOGE(FAILED, "SetInt of ATTR_CORE_TYPE failed.");
}
InitL1FusionOption();
GE_CHK_BOOL_EXEC(ge::AttrUtils::SetBool(&model, ATTR_NAME_SWITCH_FOR_L1_FUSION, is_l1_fusion_enable_),
REPORT_INNER_ERROR("E19999", "Set Attr:%s in model failed when %s",
ATTR_NAME_SWITCH_FOR_L1_FUSION.c_str(), __FUNCTION__);
GELOGE(FAILED, "SetBool of ATTR_NAME_SWITCH_FOR_L1_FUSION failed.");
return FAILED);
const DumpProperties &dump_properties = DumpManager::GetInstance().GetDumpProperties(session_id_);
bool is_op_debug = dump_properties.IsOpDebugOpen();
if (is_op_debug) {
if (!ge::AttrUtils::SetBool(&model, ATTR_OP_DEBUG_FLAG, is_op_debug)) {
REPORT_INNER_ERROR("E19999", "Set Attr:%s in model failed when %s",
ATTR_OP_DEBUG_FLAG.c_str(), __FUNCTION__);
GELOGE(FAILED, "SetBool of ATTR_OP_DEBUG_FLAG failed.");
return FAILED;
}
uint32_t op_debug_mode = dump_properties.GetOpDebugMode();
GELOGI("Get op debug mode:%d", op_debug_mode);
if (!ge::AttrUtils::SetInt(&model, ATTR_OP_DEBUG_MODE, op_debug_mode)) {
REPORT_INNER_ERROR("E19999", "Set Attr:%s in model failed when %s",
ATTR_OP_DEBUG_MODE.c_str(), __FUNCTION__);
GELOGE(FAILED, "SetBool of ATTR_OP_DEBUG_MODE failed.");
return FAILED;
}
@ -516,6 +554,8 @@ Status ModelBuilder::MergeWeights() {
// If MutableTensor failed, weight is nullptr.
(void)ge::AttrUtils::MutableTensor(op_desc, ATTR_NAME_WEIGHTS, weight);
if (weight == nullptr) {
REPORT_INNER_ERROR("E19999", "Can't get const weight in op:%s(%s) when %s",
op_desc->GetName().c_str(), op_desc->GetType().c_str(), __FUNCTION__);
GELOGE(FAILED, "Can't get const op weight, name: %s", node->GetName().c_str());
return FAILED;
}
@ -538,8 +578,15 @@ Status ModelBuilder::MergeWeights() {
continue;
}
if (weight_data.data() != nullptr) {
GE_IF_BOOL_EXEC(base_addr == nullptr, GELOGE(FAILED, "Base addr is nullptr."); return FAILED);
GE_IF_BOOL_EXEC(base_addr == nullptr,
REPORT_INNER_ERROR("E19999", "Check weight in op:%s(%s) is nullptr when %s",
op_desc->GetName().c_str(), op_desc->GetType().c_str(), __FUNCTION__);
GELOGE(FAILED, "Base addr is nullptr.");
return FAILED);
if (weight_offset_ - offset < weight_data.size()) {
REPORT_INNER_ERROR("E19999", "left weight size not enough for op:%s(%s) left_size:%zu, weight_size:%zu when %s",
op_desc->GetName().c_str(), op_desc->GetType().c_str(),
weight_offset_ - offset, weight_data.size(), __FUNCTION__);
GELOGE(FAILED, "left weight size not enough. left_size:%lu, weight_size:%lu",
weight_offset_ - offset, weight_data.size());
return FAILED;
@ -551,6 +598,9 @@ Status ModelBuilder::MergeWeights() {
auto err = memcpy_s(reinterpret_cast<void *>(dst_ptr), SECUREC_MEM_MAX_LEN, reinterpret_cast<void *>(src_ptr),
SECUREC_MEM_MAX_LEN);
if (err != EOK) {
REPORT_CALL_ERROR("E19999", "mem copy failed. errret:%u, "
"dst_ptr:%lx, dst_size:%lu, src_ptr:%lx, src_size:%lu, when %s",
err, dst_ptr, SECUREC_MEM_MAX_LEN, src_ptr, SECUREC_MEM_MAX_LEN, __FUNCTION__);
GELOGE(FAILED, "mem copy failed. errret:%u, "
"dst_ptr:%lx, dst_size:%lu, src_ptr:%lx, src_size:%lu",
err, dst_ptr, SECUREC_MEM_MAX_LEN, src_ptr, SECUREC_MEM_MAX_LEN);
@ -562,6 +612,9 @@ Status ModelBuilder::MergeWeights() {
}
auto err = memcpy_s(reinterpret_cast<void *>(dst_ptr), left_size, reinterpret_cast<void *>(src_ptr), left_size);
if (err != EOK) {
REPORT_CALL_ERROR("E19999", "mem copy failed. errret:%u, "
"dst_ptr:%lx, dst_size:%lu, src_ptr:%lx, src_size:%lu, when %s",
err, dst_ptr, SECUREC_MEM_MAX_LEN, src_ptr, SECUREC_MEM_MAX_LEN, __FUNCTION__);
GELOGE(FAILED, "mem copy failed. errret:%u, "
"dst_ptr:%lx, dst_size:%lu, src_ptr:%lx, src_size:%lu",
err, dst_ptr, SECUREC_MEM_MAX_LEN, src_ptr, SECUREC_MEM_MAX_LEN);
@ -602,6 +655,8 @@ Status ModelBuilder::SaveDataToModel(ge::Model &model, ge::GeModel &ge_model) {
}
GE_IF_BOOL_EXEC(tbe_kernel == nullptr, continue);
if (tbe_name_set.count(tbe_kernel->GetName()) > 0) {
REPORT_INNER_ERROR("E19999", "tbe_kernel name %s can't be the same, judge for op:%s(%s), when %s",
tbe_kernel->GetName().c_str(), n->GetName().c_str(), n->GetType().c_str(), __FUNCTION__);
GELOGE(FAILED, "tbe_kernel name %s can't be the same", tbe_kernel->GetName().c_str());
return FAILED;
}
@ -618,6 +673,8 @@ Status ModelBuilder::SaveDataToModel(ge::Model &model, ge::GeModel &ge_model) {
node_op_desc->TryGetExtAttr(ge::OP_EXTATTR_CUSTAICPU_KERNEL, CustAICPUKernelPtr());
GE_IF_BOOL_EXEC(cust_aicpu_kernel == nullptr, continue);
if (aicpu_name_set.count(cust_aicpu_kernel->GetName()) > 0) {
REPORT_INNER_ERROR("E19999", "aicpu_kernel name %s can't be the same, judge for op:%s(%s), when %s",
cust_aicpu_kernel->GetName().c_str(), n->GetName().c_str(), n->GetType().c_str(), __FUNCTION__);
GELOGE(FAILED, "aicpu_kernel name %s can't be the same", cust_aicpu_kernel->GetName().c_str());
return FAILED;
}
@ -640,6 +697,7 @@ Status ModelBuilder::SaveDataToModel(ge::Model &model, ge::GeModel &ge_model) {
// Add task
GeAttrValue::BYTES task_def_bytes;
if (!AttrUtils::GetZeroCopyBytes(model, MODEL_ATTR_TASKS, task_def_bytes)) {
REPORT_CALL_ERROR("E19999", "Get attr:%s in model fail when %s", MODEL_ATTR_TASKS.c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "Get zero copy bytes fail.");
return INTERNAL_ERROR;
}
@ -675,6 +733,7 @@ void ModelBuilder::SetModelVersion(ge::Model &model) {
Status ModelBuilder::PreBuildModel() {
if ((compute_graph_ == nullptr) || !(compute_graph_->IsValid())) {
REPORT_INNER_ERROR("E19999", "Check compute_graph no valid when %s", __FUNCTION__);
GELOGE(FAILED, "Graph_ is not valid.");
return FAILED;
}
@ -754,6 +813,7 @@ Status ModelBuilder::CompileSingleOp() {
// Create ge instance
std::shared_ptr<GELib> instance = ge::GELib::GetInstance();
if ((instance == nullptr) || !instance->InitFlag()) {
REPORT_INNER_ERROR("E19999", "Check GELib instance not init before when %s", __FUNCTION__);
GELOGE(ge::GE_CLI_GE_NOT_INITIALIZED, "CompileSingleOp failed.");
return ge::GE_CLI_GE_NOT_INITIALIZED;
}
@ -775,6 +835,8 @@ Status ModelBuilder::CompileSingleOp() {
(void)instance->DNNEngineManagerObj().GetDNNEngineName(node);
kernel_lib_name = op_desc->GetOpKernelLibName();
if (kernel_lib_name.empty()) {
REPORT_INNER_ERROR("E19999", "Check kernel lib name empty of op:%s(%s) when %s",
node->GetName().c_str(), node->GetType().c_str(), __FUNCTION__);
GELOGE(ge::INTERNAL_ERROR, "Get node:%s(%s) kernel lib failed.", node->GetName().c_str(),
node->GetType().c_str());
return ge::INTERNAL_ERROR;
@ -785,6 +847,8 @@ Status ModelBuilder::CompileSingleOp() {
if (kernel_info != nullptr) {
node_vector_map[kernel_lib_name].emplace_back(node);
} else {
REPORT_INNER_ERROR("E19999", "Get ops kernel info store failed for op:%s(%s), op_kernel_name:%s, when %s",
node->GetName().c_str(), node->GetType().c_str(), kernel_lib_name.c_str(), __FUNCTION__);
GELOGE(ge::GE_GRAPH_PARAM_NULLPTR, "Get op %s ops kernel info store failed", node->GetName().c_str());
return ge::GE_GRAPH_PARAM_NULLPTR;
}
@ -800,6 +864,8 @@ Status ModelBuilder::CompileSingleOp() {
GELOGI("[GEPERFTRACE] The node size of compile op of %s is %zu", kernel_lib_name.c_str(), node_vector.size());
GE_TIMESTAMP_ADD(BatchCompileOp);
if (ret != ge::SUCCESS) {
REPORT_CALL_ERROR("E19999", "Batch compile op failed, kernel lib name, node size:%zu, when %s",
node_vector.size(), __FUNCTION__);
GELOGE(ret, "Compile op failed, kernel lib name is %s", kernel_lib_name.c_str());
return ret;
}

22
ge/graph/build/run_context.cc
Unescape View File

@ -27,15 +27,21 @@ Status RunContextUtil::InitMemInfo(uint8_t *data_mem_base, uint64_t data_mem_siz
std::map<int64_t, uint64_t> mem_type_to_data_mem_size, uint8_t *weight_mem_base,
uint64_t weight_mem_size) {
if ((data_mem_size > 0) && (data_mem_base == nullptr)) {
REPORT_INNER_ERROR("E19999", "InitMemInfo param data_mem_base is null but data_mem_size = %lu", data_mem_size);
GELOGE(PARAM_INVALID, "InitMemInfo param data_mem_base is null but data_mem_size = %lu.", data_mem_size);
return PARAM_INVALID;
}
if ((weight_mem_size > 0) && (weight_mem_base == nullptr)) {
REPORT_INNER_ERROR("E19999", "InitMemInfo param weight_mem_base is null but weight_mem_size = %lu",
weight_mem_size);
GELOGE(PARAM_INVALID, "InitMemInfo param weight_mem_base is null but weight_mem_size = %lu.", weight_mem_size);
return PARAM_INVALID;
}
if (mem_type_to_data_mem_base.empty() || mem_type_to_data_mem_size.empty() ||
mem_type_to_data_mem_base.size() != mem_type_to_data_mem_size.size()) {
REPORT_INNER_ERROR("E19999", "InitMemInfo param mem_type_to_data_mem_base size[%zu] "
"is not equal to the size of mem_type_to_data_mem_size[%zu].",
mem_type_to_data_mem_base.size(), mem_type_to_data_mem_size.size());
GELOGE(PARAM_INVALID,
"InitMemInfo param mem_type_to_data_mem_base size[%zu] is not equal to the size of "
"mem_type_to_data_mem_size[%zu].",
@ -55,6 +61,7 @@ Status RunContextUtil::CreateRtModelResources(uint32_t stream_num, uint32_t even
// Create rt model
rtError_t rt_ret = rtModelCreate(&rt_model_, 0);
if (rt_ret != RT_ERROR_NONE) {
REPORT_CALL_ERROR("E19999", "call rtModelCreate fail, ret:%d, when %s", static_cast<int>(rt_ret), __FUNCTION__);
GELOGE(RT_FAILED, "rtModelCreate failed. rt_ret = %d", static_cast<int>(rt_ret));
return RT_FAILED;
}
@ -64,6 +71,8 @@ Status RunContextUtil::CreateRtModelResources(uint32_t stream_num, uint32_t even
rtStream_t stream = nullptr;
rt_ret = rtStreamCreate(&stream, 0);
if (rt_ret != RT_ERROR_NONE) {
REPORT_CALL_ERROR("E19999", "call rtStreamCreate fail, ret:%d, index:%u, when %s",
static_cast<int>(rt_ret), i, __FUNCTION__);
GELOGE(RT_FAILED, "rtStreamCreate failed. rt_ret = %d, index = %u", static_cast<int>(rt_ret), i);
return RT_FAILED;
}
@ -71,6 +80,8 @@ Status RunContextUtil::CreateRtModelResources(uint32_t stream_num, uint32_t even
rt_ret = rtModelBindStream(rt_model_, stream, 0);
if (rt_ret != RT_ERROR_NONE) {
REPORT_CALL_ERROR("E19999", "call rtModelBindStream fail, ret:%d, index:%u, when %s",
static_cast<int>(rt_ret), i, __FUNCTION__);
GELOGE(RT_FAILED, "Bind stream and model failed. rt_ret = %d, index = %u", static_cast<int>(rt_ret), i);
return RT_FAILED;
}
@ -81,6 +92,8 @@ Status RunContextUtil::CreateRtModelResources(uint32_t stream_num, uint32_t even
rtEvent_t event = nullptr;
rt_ret = rtEventCreate(&event);
if (rt_ret != RT_ERROR_NONE) {
REPORT_CALL_ERROR("E19999", "call rtEventCreate fail, ret:%d, index:%u, when %s",
static_cast<int>(rt_ret), i, __FUNCTION__);
GELOGE(RT_FAILED, "rtEventCreate failed. rt_ret = %d, index = %u", static_cast<int>(rt_ret), i);
return RT_FAILED;
}
@ -92,6 +105,8 @@ Status RunContextUtil::CreateRtModelResources(uint32_t stream_num, uint32_t even
rtLabel_t label = nullptr;
rt_ret = rtLabelCreateV2(&label, rt_model_);
if (rt_ret != RT_ERROR_NONE) {
REPORT_CALL_ERROR("E19999", "call rtLabelCreateV2 fail, ret:%d, index:%u, when %s",
static_cast<int>(rt_ret), i, __FUNCTION__);
GELOGE(RT_FAILED, "rtLabelCreate failed. rt_ret = %d, index = %u", static_cast<int>(rt_ret), i);
return RT_FAILED;
}
@ -143,12 +158,15 @@ Status RunContextUtil::CreateRunContext(Model &model, const ComputeGraphPtr &gra
GELOGD("Begin to Create RunContext, session_id = %lu", session_id);
// check params
if (graph == nullptr) {
REPORT_INNER_ERROR("E19999", "Check param graph nullptr, session_id:%lu, when %s", session_id, __FUNCTION__);
GELOGE(PARAM_INVALID, "CreateRunContext param graph is null. session_id=%lu", session_id);
return PARAM_INVALID;
}
uint32_t stream_num = 0;
if (!AttrUtils::GetInt(&model, ATTR_MODEL_STREAM_NUM, stream_num)) {
REPORT_INNER_ERROR("Get Attr:%s fail for model, session_id:%lu, when %s",
ATTR_MODEL_STREAM_NUM.c_str(), session_id, __FUNCTION__);
GELOGE(INTERNAL_ERROR, "Get stream_num attr from model_def failed. session_id=%lu", session_id);
return INTERNAL_ERROR;
}
@ -156,6 +174,8 @@ Status RunContextUtil::CreateRunContext(Model &model, const ComputeGraphPtr &gra
uint32_t event_num = 0;
if (!AttrUtils::GetInt(&model, ATTR_MODEL_EVENT_NUM, event_num)) {
REPORT_INNER_ERROR("Get Attr:%s fail for model, session_id:%lu, when %s",
ATTR_MODEL_EVENT_NUM.c_str(), session_id, __FUNCTION__);
GELOGE(INTERNAL_ERROR, "Get event_num attr from model failed. session_id=%lu", session_id);
return INTERNAL_ERROR;
}
@ -163,6 +183,8 @@ Status RunContextUtil::CreateRunContext(Model &model, const ComputeGraphPtr &gra
uint32_t label_num = 0;
if (!AttrUtils::GetInt(&model, ATTR_MODEL_LABEL_NUM, label_num)) {
REPORT_INNER_ERROR("Get Attr:%s fail for model, session_id:%lu, when %s",
ATTR_MODEL_LABEL_NUM.c_str(), session_id, __FUNCTION__);
GELOGE(INTERNAL_ERROR, "Get label_num attr from model failed. session_id=%lu", session_id);
return INTERNAL_ERROR;
}

68
ge/graph/build/stream_allocator.cc
Unescape View File

@ -76,6 +76,7 @@ Status StreamAllocator::AssignLogicalStreams(const std::map<std::string, int> &m
auto gelib = GELib::GetInstance();
if (gelib == nullptr) {
REPORT_INNER_ERROR("E19999", "Check GELib instance nullptr when %s", __FUNCTION__);
GELOGE(FAILED, "Get GELib instance failed.");
return FAILED;
}
@ -184,6 +185,8 @@ Status StreamAllocator::AssignSingleStream() {
}
if (stream_num_ > 1) {
REPORT_INNER_ERROR("E19999", "The number of ts streams is %ld, only one is supported when %s",
stream_num_, __FUNCTION__);
GELOGE(FAILED, "The number of ts streams is %ld, only one is supported.", stream_num_);
return FAILED;
}
@ -257,6 +260,9 @@ Status StreamAllocator::SetActiveStreamsByLabel() {
}
}
GE_CHK_BOOL_EXEC(AttrUtils::SetListInt(node->GetOpDesc(), ATTR_NAME_ACTIVE_STREAM_LIST, activated_stream_list),
REPORT_INNER_ERROR("E19999", "Set Attr:%s for op:%s(%s) failed when %s",
ATTR_NAME_ACTIVE_STREAM_LIST.c_str(),
node->GetName().c_str(), node->GetType().c_str(), __FUNCTION__);
GELOGE(FAILED, "SetListInt failed.");
return FAILED);
}
@ -307,6 +313,9 @@ Status StreamAllocator::SetActiveStreamsForSubgraphs() {
}
if (!AttrUtils::SetListInt(first_active_node->GetOpDesc(), ATTR_NAME_ACTIVE_STREAM_LIST, active_streams)) {
REPORT_INNER_ERROR("E19999", "Set Attr:%s for op:%s(%s) failed when %s",
ATTR_NAME_ACTIVE_STREAM_LIST.c_str(),
first_active_node->GetName().c_str(), first_active_node->GetType().c_str(), __FUNCTION__);
GELOGE(FAILED, "Set active streams for node %s failed.", first_active_node->GetName().c_str());
return FAILED;
}
@ -376,6 +385,8 @@ Status StreamAllocator::InsertOneEventInTwoNodes(const NodePtr &cur_node, const
}
if (next_stream_id == kInvalidStream) {
REPORT_INNER_ERROR("E19999", "Stream id of next_node %s(%s) should not be %ld when %s",
next_node->GetName().c_str(), next_node->GetType().c_str(), kInvalidStream, __FUNCTION__);
GELOGE(FAILED, "Stream id of next_node %s should not be %ld", next_node->GetName().c_str(), kInvalidStream);
return FAILED;
}
@ -589,8 +600,14 @@ Status StreamAllocator::OptimizeByStreamActivate() {
// -> stream(streamSwitch) -> stream(streamActivate) -> stream(stream true or false)
// No need to insert an event between node in stream(normal) and node in stream(stream true or false)
bool StreamAllocator::IsRecvNodeActivatedBySendNode(const NodePtr &send_node_ptr, const NodePtr &recv_node_ptr) const {
GE_CHECK_NOTNULL_EXEC(send_node_ptr->GetOpDesc(), GELOGE(FAILED, "op desc is nullptr"); return false);
GE_CHECK_NOTNULL_EXEC(recv_node_ptr->GetOpDesc(), GELOGE(FAILED, "op desc is nullptr"); return false);
GE_CHECK_NOTNULL_EXEC(send_node_ptr->GetOpDesc(),
REPORT_INNER_ERROR("E19999", "Check param send_node_ptr nullptr when %s", __FUNCTION__);
GELOGE(FAILED, "op desc is nullptr");
return false);
GE_CHECK_NOTNULL_EXEC(recv_node_ptr->GetOpDesc(),
REPORT_INNER_ERROR("E19999", "Check param recv_node_ptr nullptr when %s", __FUNCTION__);
GELOGE(FAILED, "op desc is nullptr");
return false);
auto cur_stream_id = send_node_ptr->GetOpDesc()->GetStreamId();
if (AttrUtils::HasAttr(recv_node_ptr->GetOpDesc(), ATTR_NAME_STREAM_LABEL)) {
// find streamActivate node
@ -714,6 +731,8 @@ Status StreamAllocator::SplitStreams(vector<set<int64_t>> &split_streams) {
continue;
}
if (stream_id > last_stream_id) {
REPORT_INNER_ERROR("E19999", "streamid(%ld) > last_stream_id(%ld), check invalid when %s",
stream_id, last_stream_id, __FUNCTION__);
GELOGE(FAILED, "SplitStreams:streamid(%ld) > last_stream_id(%ld)", stream_id, last_stream_id);
return FAILED;
}
@ -727,6 +746,8 @@ Status StreamAllocator::SplitStreams(vector<set<int64_t>> &split_streams) {
stream_continuous_2_node_num_map[continuous_stream_label]++;
// return error
if (stream_continuous_2_node_num_map[continuous_stream_label] > max_node_num_one_stream) {
REPORT_INNER_ERROR("E19999", "Check node[%s] stream_id[%ld] continuous stream label[%s] unsatisfied when %s",
op_desc->GetName().c_str(), stream_id, continuous_stream_label.c_str(), __FUNCTION__);
GELOGE(FAILED, "SplitStreams:node[%s] stream_id[%ld] continuous stream label[%s] unsatisfied ",
op_desc->GetName().c_str(), stream_id, continuous_stream_label.c_str());
return FAILED;
@ -881,6 +902,8 @@ Status StreamAllocator::UpdateActiveStreamsForSwitchNode(NodePtr &switch_node) {
GE_CHECK_NOTNULL(op_desc);
if (!AttrUtils::SetListInt(op_desc, ATTR_NAME_ACTIVE_STREAM_LIST, stream_ids)) {
REPORT_INNER_ERROR("E19999", "Set Attr:%s fail for op:%s(%s) when %s", ATTR_NAME_ACTIVE_STREAM_LIST.c_str(),
op_desc->GetName().c_str(), op_desc->GetType().c_str(), __FUNCTION__);
GELOGE(FAILED, "SetListInt failed.");
return FAILED;
}
@ -895,6 +918,8 @@ Status StreamAllocator::InsertActiveNodesAfterSwitch(NodePtr &switch_node, vecto
vector<string> ori_active_label_list;
if (!AttrUtils::GetListStr(switch_desc, ATTR_NAME_ACTIVE_LABEL_LIST, ori_active_label_list) ||
ori_active_label_list.empty()) {
REPORT_INNER_ERROR("E19999", "Get Attr:%s fail for op:%s(%s) when %s", ATTR_NAME_ACTIVE_LABEL_LIST.c_str(),
switch_node->GetName().c_str(), switch_node->GetType().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "Get active label list of switch %s failed.", switch_node->GetName().c_str());
return INTERNAL_ERROR;
}
@ -918,6 +943,8 @@ Status StreamAllocator::InsertActiveNodesAfterSwitch(NodePtr &switch_node, vecto
for (auto &active_node : added_active_nodes) {
GE_CHECK_NOTNULL(switch_node->GetOutControlAnchor());
if (switch_node->GetOutControlAnchor()->LinkTo(active_node->GetInControlAnchor()) != GRAPH_SUCCESS) {
REPORT_CALL_ERROR("E19999", "Link from %s to %s failed when %s",
switch_node->GetName().c_str(), active_node->GetName().c_str(), __FUNCTION__);
GELOGE(FAILED, "Link %s to %s failed.", switch_node->GetName().c_str(), active_node->GetName().c_str());
return FAILED;
}
@ -933,6 +960,8 @@ Status StreamAllocator::UpdateActiveStreamsForActiveNode(const vector<set<int64_
vector<uint32_t> new_active_streams = active_streams;
for (uint32_t logical_stream : active_streams) {
if (static_cast<size_t>(logical_stream) >= split_streams.size()) {
REPORT_INNER_ERROR("E19999", "Check logical stream:%u is out of range:%zu when %s",
logical_stream, split_streams.size(), __FUNCTION__);
GELOGE(FAILED, "logical stream is out of range.");
return FAILED;
}
@ -951,6 +980,8 @@ Status StreamAllocator::UpdateActiveStreamsForActiveNode(const vector<set<int64_
}
}
if (!AttrUtils::SetListInt(node->GetOpDesc(), ATTR_NAME_ACTIVE_STREAM_LIST, new_active_streams)) {
REPORT_INNER_ERROR("E19999", "Set Attr:%s fail for op:%s(%s) when %s", ATTR_NAME_ACTIVE_STREAM_LIST.c_str(),
node->GetName().c_str(), node->GetType().c_str(), __FUNCTION__);
GELOGE(FAILED, "Set active streams for node %s failed.", node->GetName().c_str());
return FAILED;
}
@ -991,6 +1022,8 @@ Status StreamAllocator::UpdateActiveStreamsForSubgraphs() const {
new_active_streams.emplace(static_cast<uint32_t>(new_split_stream));
active_streams.assign(new_active_streams.begin(), new_active_streams.end());
if (!AttrUtils::SetListInt(active_op, ATTR_NAME_ACTIVE_STREAM_LIST, active_streams)) {
REPORT_INNER_ERROR("E19999", "Set Attr:%s fail for op:%s(%s) when %s", ATTR_NAME_ACTIVE_STREAM_LIST.c_str(),
active_op->GetName().c_str(), active_op->GetType().c_str(), __FUNCTION__);
GELOGE(FAILED, "Set active streams for node %s failed.", active_node->GetName().c_str());
return FAILED;
}
@ -1059,6 +1092,8 @@ Status StreamAllocator::SetActiveStreamsForLoop() {
NodePtr pre_switch_node = FindSwitchNodeBeforeLoopActiveNode(node);
if (pre_switch_node == nullptr) {
REPORT_INNER_ERROR("E19999", "Find switch node before loop active node %s fail when %s",
node->GetName().c_str(), __FUNCTION__);
GELOGE(FAILED, "find switch node before loop active node %s failed", node->GetName().c_str());
return FAILED;
}
@ -1066,6 +1101,9 @@ Status StreamAllocator::SetActiveStreamsForLoop() {
if (!AttrUtils::GetListStr(node->GetOpDesc(), ATTR_NAME_ACTIVE_LABEL_LIST, activated_label_list) ||
activated_label_list.empty()) {
GE_CHK_BOOL_EXEC(AttrUtils::SetListInt(node->GetOpDesc(), ATTR_NAME_ACTIVE_STREAM_LIST, loop_active_streams),
REPORT_INNER_ERROR("E19999", "Set Attr:%s fail for op:%s(%s) when %s",
ATTR_NAME_ACTIVE_STREAM_LIST.c_str(),
node->GetName().c_str(), node->GetType().c_str(), __FUNCTION__);
GELOGE(FAILED, "SetListInt failed.");
return FAILED);
for (const auto &stream_id : loop_active_streams) {
@ -1112,6 +1150,8 @@ Status StreamAllocator::CheckStreamActived() const {
uint32_t stream_id = static_cast<uint32_t>(node->GetOpDesc()->GetStreamId());
auto iter = find(active_streams.begin(), active_streams.end(), stream_id);
if (iter != active_streams.end()) {
REPORT_INNER_ERROR("E19999", "Node:%s(%s) cannot active its own stream %u, check invalid when %s",
node->GetName().c_str(), node->GetType().c_str(), stream_id, __FUNCTION__);
GELOGE(FAILED, "Node %s cannot active its own stream %u.", node->GetName().c_str(), stream_id);
return FAILED;
}
@ -1139,6 +1179,7 @@ Status StreamAllocator::RefreshContinuousEvents() {
for (size_t i = 0; i < send_events.size(); i++) {
auto find_it = old_to_new_events.find(send_events[i]);
if (find_it == old_to_new_events.end()) {
REPORT_INNER_ERROR("E19999", "Check invalid send event %u when %s", send_events[i], __FUNCTION__);
GELOGE(FAILED, "RefreshContinuousEvents: invalid send event %u", send_events[i]);
return FAILED;
}
@ -1152,6 +1193,7 @@ Status StreamAllocator::RefreshContinuousEvents() {
for (size_t i = 0; i < recv_events.size(); i++) {
auto find_it = old_to_new_events.find(recv_events[i]);
if (find_it == old_to_new_events.end()) {
REPORT_INNER_ERROR("E19999", "Check invalid recv event %u when %s", recv_events[i], __FUNCTION__);
GELOGE(FAILED, "RefreshContinuousEvents: invalid recv event %u", recv_events[i]);
return FAILED;
}
@ -1180,7 +1222,11 @@ Status StreamAllocator::InsertSyncEventNodes() {
int64_t temp_stream_id = node->GetOpDesc()->GetStreamId();
op_desc_ptr->SetStreamId(temp_stream_id);
GE_CHK_BOOL_EXEC(AttrUtils::SetInt(op_desc_ptr, RECV_ATTR_EVENT_ID, event_id), GELOGE(FAILED, "SetInt failed.");
GE_CHK_BOOL_EXEC(AttrUtils::SetInt(op_desc_ptr, RECV_ATTR_EVENT_ID, event_id),
REPORT_INNER_ERROR("E19999", "Set Attr:%s for op:%s(%s) failed, event_id:%u, when %s",
RECV_ATTR_EVENT_ID.c_str(),
node->GetName().c_str(), node->GetType().c_str(), event_id, __FUNCTION__);
GELOGE(FAILED, "SetInt failed.");
return FAILED);
(void)AttrUtils::SetListStr(op_desc_ptr, ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES,
std::move(std::vector<std::string>()));
@ -1189,6 +1235,8 @@ Status StreamAllocator::InsertSyncEventNodes() {
GE_CHECK_NOTNULL(recv_node->GetOutControlAnchor());
Status status = GraphUtils::AddEdge(recv_node->GetOutControlAnchor(), node->GetInControlAnchor());
if (status != SUCCESS) {
REPORT_INNER_ERROR("E19999", "Add edge from node %s to node %s failed when %s",
recv_node->GetName().c_str(), node->GetName().c_str(), __FUNCTION__);
GELOGE(status, "Add edge for node %s and node %s failed.", recv_node->GetName().c_str(),
node->GetName().c_str());
return status;
@ -1217,6 +1265,8 @@ Status StreamAllocator::InsertSyncEventNodes() {
GE_CHECK_NOTNULL(send_node->GetInControlAnchor());
Status status = GraphUtils::AddEdge(node->GetOutControlAnchor(), send_node->GetInControlAnchor());
if (status != SUCCESS) {
REPORT_INNER_ERROR("E19999", "Add edge from node %s to node %s failed when %s",
node->GetName().c_str(), send_node->GetName().c_str(), __FUNCTION__);
GELOGE(status, "Add edge for node %s and node %s failed.", node->GetName().c_str(),
send_node->GetName().c_str());
return status;
@ -1228,6 +1278,8 @@ Status StreamAllocator::InsertSyncEventNodes() {
Status status = whole_graph_->InsertGraphEvents();
if (status != SUCCESS) {
REPORT_CALL_ERROR("E19999", "Insert Graph Events fail, graph:%s, when %s",
whole_graph_->GetName().c_str(), __FUNCTION__);
GELOGE(status, "Graph ReorderEventNodes failed");
return status;
}
@ -1274,6 +1326,8 @@ Status StreamAllocator::GetMaxStreamAndTask(bool huge_stream, uint32_t &max_stre
}
rtError_t ret = rtGetMaxStreamAndTask(stream_type, &max_stream_count, &max_task_count);
if (ret != RT_ERROR_NONE) {
REPORT_CALL_ERROR("E19999", "call rtGetMaxStreamAndTask fail, ret:%d, stream_type:%u, when %s",
static_cast<int>(ret), stream_type, __FUNCTION__);
GELOGE(FAILED, "Get max stream and task count by rts failed.");
return FAILED;
}
@ -1416,6 +1470,7 @@ Status StreamAllocator::AddActiveNodes(NodePtr &switch_node, const vector<string
for (size_t i = 0; i < label_num; i++) {
const string &active_label = ori_active_label_list[i];
if (labeled_streams_.find(active_label) == labeled_streams_.end()) {
REPORT_INNER_ERROR("E19999", "can not find stream label:%s when %s", active_label.c_str(), __FUNCTION__);
GELOGE(FAILED, "can not find stream label %s", active_label.c_str());
return FAILED;
}
@ -1442,11 +1497,15 @@ Status StreamAllocator::AddActiveNodes(NodePtr &switch_node, const vector<string
}
GE_CHECK_NOTNULL(switch_node->GetOutControlAnchor());
if (switch_node->GetOutControlAnchor()->Unlink(node->GetInControlAnchor()) != GRAPH_SUCCESS) {
REPORT_CALL_ERROR("Unlink %s to %s failed when %s",
switch_node->GetName().c_str(), node->GetName().c_str(), __FUNCTION__);
GELOGE(FAILED, "Unlink %s to %s failed.", switch_node->GetName().c_str(), node->GetName().c_str());
return FAILED;
}
GE_CHECK_NOTNULL(active_node->GetOutControlAnchor());
if (active_node->GetOutControlAnchor()->LinkTo(node->GetInControlAnchor()) != GRAPH_SUCCESS) {
REPORT_CALL_ERROR("Link %s to %s failed when %s",
active_node->GetName().c_str(), node->GetName().c_str(), __FUNCTION__);
GELOGE(FAILED, "Link %s to %s failed.", active_node->GetName().c_str(), node->GetName().c_str());
return FAILED;
}
@ -1477,12 +1536,15 @@ Status StreamAllocator::AddActiveNodes(NodePtr &switch_node, const vector<string
Status StreamAllocator::SetActiveStreamList(NodePtr &active_node, const string &active_label) {
if (labeled_streams_.find(active_label) == labeled_streams_.end()) {
REPORT_INNER_ERROR("E19999", "Can not find stream label:%s when %s", active_label.c_str(), __FUNCTION__);
GELOGE(FAILED, "Can not find stream label %s.", active_label.c_str());
return FAILED;
}
set<int64_t> &streams = labeled_streams_[active_label];
vector<int64_t> active_streams(streams.begin(), streams.end());
if (!AttrUtils::SetListInt(active_node->GetOpDesc(), ATTR_NAME_ACTIVE_STREAM_LIST, active_streams)) {
REPORT_INNER_ERROR("E19999", "Set Attr:%s fail for op:%s(%s) when %s", ATTR_NAME_ACTIVE_STREAM_LIST.c_str(),
active_node->GetName().c_str(), active_node->GetType().c_str(), __FUNCTION__);
GELOGE(FAILED, "SetListInt of %s failed.", ATTR_NAME_ACTIVE_STREAM_LIST.c_str());
return FAILED;
}

9
ge/graph/build/stream_graph_optimizer.cc
Unescape View File

@ -14,6 +14,9 @@
* limitations under the License.
*/
#include "stream_graph_optimizer.h"
#include <securec.h>
#include "common/util.h"
#include "framework/common/debug/ge_log.h"
#include "graph/utils/node_utils.h"
@ -122,6 +125,9 @@ Status StreamGraphOptimizer::OptimizeStreamedSubGraph(const ComputeGraphPtr &com
GE_CHECK_NOTNULL(op_desc);
int64_t stream_id = op_desc->GetStreamId();
if (static_cast<size_t>(stream_id) >= run_context.graphStreamList.size()) {
REPORT_INNER_ERROR("E19999", "Check stream_id:%ld in op:%s(%s) is bigger than run_context.graphStreamList.size():%zu "
"when %s", stream_id, op_desc->GetName().c_str(),
op_desc->GetType().c_str(), run_context.graphStreamList.size(), __FUNCTION__);
GELOGE(FAILED, "stream_id %ld is bigger than run_context.graphStreamList.size() %zu", stream_id,
run_context.graphStreamList.size());
return FAILED;
@ -135,6 +141,9 @@ Status StreamGraphOptimizer::OptimizeStreamedSubGraph(const ComputeGraphPtr &com
for (auto iter = graph_optimizers.begin(); iter != graph_optimizers.end(); ++iter) {
GE_CHECK_NOTNULL(*iter);
Status ret = (*iter)->OptimizeStreamGraph(*subgraph, run_context);
REPORT_CALL_ERROR("E19999", "Call optimize streamed subgraph failed, subgraph: %s, engine_name: %s, graph "
"Optimizer num: %zu, ret: %u", subgraph->GetName().c_str(), engine_name.c_str(),
graph_optimizers.size(), ret);
if (ret != SUCCESS) {
GELOGE(
ret,

89
ge/graph/build/task_generator.cc
View File

File diff suppressed because it is too large Load Diff

2
ge/graph/common/bcast.cc
Unescape View File

@ -73,6 +73,8 @@ Status BCast::SetShapeDifferentInfo(const kVecInt &x, const kVecInt &y) {
y_bcast_i = x_i;
grad_y_reduce_idx_.push_back(n - 1 - i);
} else {
REPORT_INNER_ERROR("E19999", "SetShapeDifferentInfo failed. Two tensor shapes are not compatible "
"according to the broadcasting rule.");
GELOGE(domi::PARAM_INVALID,
"SetShapeDifferentInfo failed. Two tensor shapes are not compatible "
"according to the broadcasting rule.");

7
ge/graph/common/bcast.h
Unescape View File

@ -111,11 +111,14 @@ class BCast {
const std::function<OutT(InT const &, InT const &)> &func) {
Status ret;
if (func == nullptr) {
REPORT_INNER_ERROR("E19999", "Check param func nullptr when %s", __FUNCTION__);
GELOGE(domi::PARAM_INVALID, "Param func is null");
return domi::PARAM_INVALID;
}
// Min input num is 2
if (input.size() < kMinDimNum) {
REPORT_INNER_ERROR("E19999", "Param input.size():%zu < %zu, check invalid when %s",
input.size(), kMinDimNum, __FUNCTION__);
GELOGE(domi::PARAM_INVALID, "Input size is smaller than two.");
return domi::PARAM_INVALID;
}
@ -149,11 +152,14 @@ class BCast {
Status BCastComputeCheck(const std::vector<ConstGeTensorPtr> &input, std::vector<OutT> &v_output,
const std::function<OutT(InT const &, InT const &, DataType &type, Status &)> &func) {
if (func == nullptr) {
REPORT_INNER_ERROR("E19999", "Check param func nullptr when %s", __FUNCTION__);
GELOGE(PARAM_INVALID, "Param func is null");
return PARAM_INVALID;
}
// Min input num is 2
if (input.size() < kMinDimNum) {
REPORT_INNER_ERROR("E19999", "Param input.size():%zu < %zu, check invalid when %s",
input.size(), kMinDimNum, __FUNCTION__);
GELOGE(PARAM_INVALID, "Input size is smaller than two.");
return PARAM_INVALID;
}
@ -179,6 +185,7 @@ class BCast {
auto value = func((*(reinterpret_cast<const InT *>(x1_data) + x_index)),
(*(reinterpret_cast<const InT *>(x2_data) + y_index)), data_type, ret);
if (ret != SUCCESS) {
REPORT_INNER_ERROR("E19999", "BCastComputeCheck func execute failed, datatype is %d.", data_type);
GELOGE(ret, "BCastComputeCheck func execute failed, datatype is %d.", data_type);
return ret;
}

18
ge/graph/common/omg_util.cc
Unescape View File

@ -36,6 +36,8 @@ Status GetOriginalType(const ge::NodePtr &node, string &type) {
GE_CHECK_NOTNULL(node->GetOpDesc());
bool ret = ge::AttrUtils::GetStr(node->GetOpDesc(), ATTR_NAME_FRAMEWORK_ORIGINAL_TYPE, type);
if (!ret) {
REPORT_INNER_ERROR("E19999", "Get Attr:%s fail for op:%s(%s) when %s", ATTR_NAME_FRAMEWORK_ORIGINAL_TYPE.c_str(),
node->GetName().c_str(), node->GetType().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "Get FrameWorkOp original type [%s]", type.c_str());
return INTERNAL_ERROR;
}
@ -55,6 +57,8 @@ Status SetStreamLabel(const ge::NodePtr &node, const std::string &label) {
GE_CHECK_NOTNULL(tmp_desc);
if (!AttrUtils::SetStr(tmp_desc, ge::ATTR_NAME_STREAM_LABEL, label)) {
REPORT_INNER_ERROR("E19999", "Set Attr:%s fail for op:%s(%s) when %s", ATTR_NAME_STREAM_LABEL.c_str(),
node->GetName().c_str(), node->GetType().c_str(), __FUNCTION__);
GELOGE(FAILED, "Op: %s set ATTR_NAME_STREAM_LABEL failed", node->GetName().c_str());
return FAILED;
}
@ -72,6 +76,8 @@ Status SetCycleEvent(const ge::NodePtr &node) {
OpDescPtr tmp_desc = node->GetOpDesc();
GE_CHECK_NOTNULL(tmp_desc);
if (!AttrUtils::SetBool(tmp_desc, ge::ATTR_NAME_STREAM_CYCLE_EVENT_FLAG, true)) {
REPORT_INNER_ERROR("E19999", "Set Attr:%s fail for op:%s(%s) when %s", ATTR_NAME_STREAM_CYCLE_EVENT_FLAG.c_str(),
node->GetName().c_str(), node->GetType().c_str(), __FUNCTION__);
GELOGE(FAILED, "Op: %s set ATTR_NAME_STREAM_CYCLE_EVENT_FLAG failed", node->GetName().c_str());
return FAILED;
}
@ -90,6 +96,8 @@ Status SetActiveLabelList(const ge::NodePtr &node, const std::vector<std::string
OpDescPtr tmp_desc = node->GetOpDesc();
GE_CHECK_NOTNULL(tmp_desc);
if (!AttrUtils::SetListStr(tmp_desc, ge::ATTR_NAME_ACTIVE_LABEL_LIST, active_label_list)) {
REPORT_INNER_ERROR("E19999", "Set Attr:%s fail for op:%s(%s) when %s", ATTR_NAME_ACTIVE_LABEL_LIST.c_str(),
node->GetName().c_str(), node->GetType().c_str(), __FUNCTION__);
GELOGE(FAILED, "Op: %s set ATTR_NAME_ACTIVE_LABEL_LIST failed", node->GetName().c_str());
return FAILED;
}
@ -108,6 +116,8 @@ Status SetSwitchBranchNodeLabel(const ge::NodePtr &node, const std::string &bran
OpDescPtr tmp_desc = node->GetOpDesc();
GE_CHECK_NOTNULL(tmp_desc);
if (!AttrUtils::SetStr(tmp_desc, ge::ATTR_NAME_SWITCH_BRANCH_NODE_LABEL, branch_label)) {
REPORT_INNER_ERROR("E19999", "Set Attr:%s fail for op:%s(%s) when %s", ATTR_NAME_SWITCH_BRANCH_NODE_LABEL.c_str(),
node->GetName().c_str(), node->GetType().c_str(), __FUNCTION__);
GELOGE(FAILED, "Op: %s set ATTR_NAME_SWITCH_BRANCH_NODE_LABEL failed", node->GetName().c_str());
return FAILED;
}
@ -126,6 +136,8 @@ Status SetSwitchTrueBranchFlag(const ge::NodePtr &node, bool value) {
OpDescPtr tmp_desc = node->GetOpDesc();
GE_CHECK_NOTNULL(tmp_desc);
if (!AttrUtils::SetBool(tmp_desc, ge::ATTR_NAME_SWITCH_TRUE_BRANCH_FLAG, value)) {
REPORT_INNER_ERROR("E19999", "Set Attr:%s fail for op:%s(%s) when %s", ATTR_NAME_SWITCH_TRUE_BRANCH_FLAG.c_str(),
node->GetName().c_str(), node->GetType().c_str(), __FUNCTION__);
GELOGE(FAILED, "Op: %s set ATTR_NAME_SWITCH_TRUE_BRANCH_FLAG failed", node->GetName().c_str());
return FAILED;
}
@ -144,6 +156,8 @@ Status SetOriginalNodeName(const ge::NodePtr &node, const std::string &orig_name
OpDescPtr tmp_desc = node->GetOpDesc();
GE_CHECK_NOTNULL(tmp_desc);
if (!AttrUtils::SetStr(tmp_desc, ge::ATTR_NAME_ORIG_NODE_NAME, orig_name)) {
REPORT_INNER_ERROR("E19999", "Set Attr:%s fail for op:%s(%s) when %s", ATTR_NAME_ORIG_NODE_NAME.c_str(),
node->GetName().c_str(), node->GetType().c_str(), __FUNCTION__);
GELOGE(FAILED, "Op: %s set ATTR_NAME_ORIG_NODE_NAME failed", node->GetName().c_str());
return FAILED;
}
@ -161,6 +175,8 @@ Status SetCyclicDependenceFlag(const ge::NodePtr &node) {
OpDescPtr tmp_desc = node->GetOpDesc();
GE_CHECK_NOTNULL(tmp_desc);
if (!AttrUtils::SetBool(tmp_desc, ge::ATTR_NAME_CYCLIC_DEPENDENCE_FLAG, true)) {
REPORT_INNER_ERROR("E19999", "Set Attr:%s fail for op:%s(%s) when %s", ATTR_NAME_CYCLIC_DEPENDENCE_FLAG.c_str(),
node->GetName().c_str(), node->GetType().c_str(), __FUNCTION__);
GELOGE(FAILED, "Op: %s set ATTR_NAME_CYCLIC_DEPENDENCE_FLAG failed", node->GetName().c_str());
return FAILED;
}
@ -180,6 +196,8 @@ Status SetNextIteration(const ge::NodePtr &node, const std::string &next) {
GE_CHECK_NOTNULL(tmp_desc);
if (!AttrUtils::SetStr(tmp_desc, ge::ATTR_NAME_NEXT_ITERATION, next)) {
REPORT_INNER_ERROR("E19999", "Set Attr:%s fail for op:%s(%s) when %s", ATTR_NAME_NEXT_ITERATION.c_str(),
node->GetName().c_str(), node->GetType().c_str(), __FUNCTION__);
GELOGE(FAILED, "Op: %s set ATTR_NAME_NEXT_ITERATION failed", node->GetName().c_str());
return FAILED;
}

30
ge/graph/execute/graph_execute.cc
Unescape View File

@ -40,6 +40,7 @@ GraphExecutor::~GraphExecutor() {
rtError_t rt_ret;
rt_ret = rtFreeHost(buffer_addr);
if (rt_ret != RT_ERROR_NONE) {
REPORT_CALL_ERROR("E19999", "Call rtFreeHost fail, ret:0x%X when %s", rt_ret, __FUNCTION__);
GELOGE(RT_FAILED, "[GraphManager] subgraph free buffer failed, ret: 0x%X", rt_ret);
}
}
@ -51,14 +52,17 @@ GraphExecutor::~GraphExecutor() {
Status GraphExecutor::SetCondition(std::mutex *mutex, std::condition_variable *cond,
std::shared_ptr<GraphModelListener> listener) {
if (mutex == nullptr) {
REPORT_INNER_ERROR("E19999", "Check param mutex nullptr when %s", __FUNCTION__);
GELOGE(GE_GRAPH_PARAM_NULLPTR, "[SetCondition] input param mutex is nullptr.");
return GE_GRAPH_PARAM_NULLPTR;
}
if (cond == nullptr) {
REPORT_INNER_ERROR("E19999", "Check param cond nullptr when %s", __FUNCTION__);
GELOGE(GE_GRAPH_PARAM_NULLPTR, "[SetCondition] input param cond is nullptr.");
return GE_GRAPH_PARAM_NULLPTR;
}
if (listener == nullptr) {
REPORT_INNER_ERROR("E19999", "Check param listener nullptr when %s", __FUNCTION__);
GELOGE(GE_GRAPH_PARAM_NULLPTR, "[SetCondition] input param listener is nullptr.");
return GE_GRAPH_PARAM_NULLPTR;
}
@ -75,6 +79,7 @@ Status GraphExecutor::SetCondition(std::mutex *mutex, std::condition_variable *c
Status GraphExecutor::SetGraphContext(GraphContextPtr graph_context_ptr) {
if (graph_context_ptr == nullptr) {
REPORT_INNER_ERROR("E19999", "Check param graph_context_ptr nullptr when %s", __FUNCTION__);
GELOGE(GE_GRAPH_PARAM_NULLPTR, "[SetGraphContext] input param graph_context_ptr is nullptr");
return GE_GRAPH_PARAM_NULLPTR;
}
@ -101,6 +106,7 @@ Status GraphExecutor::FreeInOutBuffer() {
rtError_t rt_ret;
rt_ret = rtFreeHost(*iter);
if (rt_ret != RT_ERROR_NONE) {
REPORT_CALL_ERROR("E19999", "Call rtFreeHost fail, ret:0x%X when %s", rt_ret, __FUNCTION__);
GELOGE(RT_FAILED, "[GraphManager] subgraph free buffer failed, ret: 0x%X", rt_ret);
(void)buffer_addr_.erase(buffer_addr_.begin(), iter);
return GE_GRAPH_FREE_FAILED;
@ -146,6 +152,8 @@ Status GraphExecutor::MallocInOutBuffer(const std::vector<uint64_t> &buffer_size
void *tmp_buf = nullptr;
rt_ret = rtMallocHost(&tmp_buf, buffer_size[i]);
if (rt_ret != RT_ERROR_NONE) {
REPORT_CALL_ERROR("E19999", "Call rtMallocHost fail, size:%lu, ret:0x%X when %s",
buffer_size[i], rt_ret, __FUNCTION__);
GELOGE(RT_FAILED, "[GraphManager] subgraph malloc buffer failed, ret: 0x%X", rt_ret);
return GE_GRAPH_MALLOC_FAILED;
}
@ -191,6 +199,8 @@ Status GraphExecutor::PrepareInputData(const std::vector<GeTensor> &input_tensor
rtError_t rt_ret = rtMemcpy(addrVec[i], bufferSizeVec[i], in_tensor->GetData().data(),
in_tensor->GetData().size(), RT_MEMCPY_HOST_TO_HOST);
if (rt_ret != RT_ERROR_NONE) {
REPORT_CALL_ERROR("E19999", "Call rtMemcpy fail, dst_size:%lu, src_size:%zu, ret:0x%X when %s",
bufferSizeVec[i], in_tensor->GetData().size(), rt_ret, __FUNCTION__);
GELOGE(RT_FAILED, "Call rt api failed, ret: 0x%X", rt_ret);
return RT_FAILED;
}
@ -250,6 +260,8 @@ Status GraphExecutor::SyncExecuteModel(uint32_t model_id, const std::vector<GeTe
}
if (graph_run_listener_->ResetResult() != SUCCESS) {
REPORT_CALL_ERROR("E19999", "Call graph_run_listener_.ResetResult fail, model_id:%u, when %s",
model_id, __FUNCTION__);
GELOGE(GE_GRAPH_EXECUTE_FAILED, "Reset result failed");
return GE_GRAPH_EXECUTE_FAILED;
}
@ -273,6 +285,8 @@ Status GraphExecutor::SyncExecuteModel(uint32_t model_id, const std::vector<GeTe
// Run graph return
uint32_t result_code = graph_run_listener_->GetResultCode();
if (result_code != SUCCESS && result_code != END_OF_SEQUENCE) {
REPORT_CALL_ERROR("E19999", "Graph_run_listener_ run fail, result:%u, model_id:%u, when %s",
result_code, model_id, __FUNCTION__);
GELOGE(GE_GRAPH_EXECUTE_FAILED, "[GraphExecutor] execute model failed, ret=%u, modelId=%u.", result_code,
model_id);
return GE_GRAPH_EXECUTE_FAILED;
@ -281,10 +295,14 @@ Status GraphExecutor::SyncExecuteModel(uint32_t model_id, const std::vector<GeTe
for (size_t i = 0; i < output_data.blobs.size(); ++i) {
DataBuffer outputDataTmp = output_data.blobs[i];
CHECK_FALSE_EXEC(outputDataTmp.length != 0,
REPORT_INNER_ERROR("E19999", "Param output_data.length is 0 in model:%u, check invalid, when %s",
model_id, __FUNCTION__);
GELOGE(GE_GRAPH_EXECUTE_FAILED, "Failed to allocate memory, length is 0.");
return GE_GRAPH_EXECUTE_FAILED);
std::unique_ptr<uint8_t> outBufTmp(new (std::nothrow) uint8_t[outputDataTmp.length]);
if (outBufTmp == nullptr) {
REPORT_INNER_ERROR("E19999", "New output buffer fail, length:%lu, model:%u, when %s",
outputDataTmp.length, model_id, __FUNCTION__);
GELOGE(FAILED, "Failed to allocate memory.");
return FAILED;
}
@ -292,6 +310,8 @@ Status GraphExecutor::SyncExecuteModel(uint32_t model_id, const std::vector<GeTe
rtError_t ret_value = rtMemcpy(outBufTmp.get(), outputDataTmp.length, outputDataTmp.data, outputDataTmp.length,
RT_MEMCPY_HOST_TO_HOST);
CHECK_FALSE_EXEC(ret_value == RT_ERROR_NONE,
REPORT_CALL_ERROR("E19999", "Call rtMemcpy fail, dst_size:%lu, src_size:%zu, ret:0x%X when %s",
outputDataTmp.length, outputDataTmp.length, ret_value, __FUNCTION__);
GELOGE(GE_GRAPH_EXECUTE_FAILED, "Call rt api rtMemcpy failed, ret: 0x%X", ret);
return GE_GRAPH_EXECUTE_FAILED);
GeTensor outTensor;
@ -344,6 +364,8 @@ Status GraphExecutor::ExecuteGraph(GraphId graph_id, const GeRootModelPtr &ge_ro
last_graph_id_ = graph_id;
if (!init_flag_) {
REPORT_INNER_ERROR("E19999", "No SetCondition called before, graph:%u, check invalid when %s",
graph_id, __FUNCTION__);
GELOGE(GE_GRAPH_EXECUTE_NOT_INIT, "[GraphExecutor] AI Core Engine without calling SetCondition!");
return GE_GRAPH_EXECUTE_NOT_INIT;
}
@ -392,10 +414,12 @@ Status GraphExecutor::AsyncExecuteModel(uint32_t model_id, const std::vector<Inp
GELOGI("RunAsync success.");
} catch (std::bad_alloc &) {
REPORT_INNER_ERROR("E19999", "Bad memory allocation exception occur when %s failed", __FUNCTION__);
GELOGE(MEMALLOC_FAILED, "RunAsync failed, bad memory allocation occur !");
CsaInteract::GetInstance().WriteErrorCode(FAILED, ERROR_MODULE_FMK, JOBSUBSTATE_GRAPH_EXEC);
return MEMALLOC_FAILED;
} catch (...) {
REPORT_INNER_ERROR("E19999", "Some exceptions occur when %s failed", __FUNCTION__);
GELOGE(FAILED, "RunAsync failed, some exceptions occur !");
CsaInteract::GetInstance().WriteErrorCode(FAILED, ERROR_MODULE_FMK, JOBSUBSTATE_GRAPH_EXEC);
return FAILED;
@ -415,10 +439,12 @@ Status GraphExecutor::DataInput(const InputData &input_data, OutputData &output_
return ret;
}
} catch (std::bad_alloc &) {
REPORT_INNER_ERROR("E19999", "Bad memory allocation exception occur when %s failed", __FUNCTION__);
GELOGE(MEMALLOC_FAILED, "DataInput failed, bad memory allocation occur !");
CsaInteract::GetInstance().WriteErrorCode(FAILED, ERROR_MODULE_FMK, JOBSUBSTATE_GRAPH_EXEC);
return MEMALLOC_FAILED;
} catch (...) {
REPORT_INNER_ERROR("E19999", "Some exceptions occur when %s failed", __FUNCTION__);
GELOGE(FAILED, "DataInput failed, some exceptions occur !");
CsaInteract::GetInstance().WriteErrorCode(FAILED, ERROR_MODULE_FMK, JOBSUBSTATE_GRAPH_EXEC);
return FAILED;
@ -439,10 +465,12 @@ Status GraphExecutor::GetInputOutputDescInfo(const uint32_t model_id, vector<Inp
return ret;
}
} catch (std::bad_alloc &) {
REPORT_INNER_ERROR("E19999", "Bad memory allocation exception occur when %s failed", __FUNCTION__);
GELOGE(MEMALLOC_FAILED, "GetInputOutputDescInfo failed, bad memory allocation occur !");
CsaInteract::GetInstance().WriteErrorCode(FAILED, ERROR_MODULE_FMK, JOBSUBSTATE_GRAPH_EXEC);
return MEMALLOC_FAILED;
} catch (...) {
REPORT_INNER_ERROR("E19999", "Some exceptions occur when %s failed", __FUNCTION__);
GELOGE(FAILED, "GetInputOutputDescInfo failed, some exceptions occur !");
CsaInteract::GetInstance().WriteErrorCode(FAILED, ERROR_MODULE_FMK, JOBSUBSTATE_GRAPH_EXEC);
return FAILED;
@ -466,10 +494,12 @@ Status GraphExecutor::GetInputOutputDescInfo(const uint32_t model_id, vector<Inp
return ret;
}
} catch (std::bad_alloc &) {
REPORT_INNER_ERROR("E19999", "Bad memory allocation exception occur when %s failed", __FUNCTION__);
GELOGE(MEMALLOC_FAILED, "GetInputOutputDescInfo failed, bad memory allocation occur !");
CsaInteract::GetInstance().WriteErrorCode(FAILED, ERROR_MODULE_FMK, JOBSUBSTATE_GRAPH_EXEC);
return MEMALLOC_FAILED;
} catch (...) {
REPORT_INNER_ERROR("E19999", "Some exceptions occur when %s failed", __FUNCTION__);
GELOGE(FAILED, "GetInputOutputDescInfo failed, some exceptions occur !");
CsaInteract::GetInstance().WriteErrorCode(FAILED, ERROR_MODULE_FMK, JOBSUBSTATE_GRAPH_EXEC);
return FAILED;

16
ge/graph/label/case_label_maker.cc
Unescape View File

@ -42,6 +42,8 @@ Status CaseOpLabelMaker::Run(uint32_t &label_index) {
const auto graph_names = case_desc->GetSubgraphInstanceNames();
if (graph_names.empty() || graph_names.size() > kMaxCaseBranch) {
REPORT_INNER_ERROR("E19999", "Node:%s(%s) subgraph size: %zu, check invalid when %s", case_desc->GetName().c_str(),
case_desc->GetType().c_str(), graph_names.size(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "Node: %s has invalid subgraph, graph size: %zu.", case_desc->GetName().c_str(),
graph_names.size());
return FAILED;
@ -67,6 +69,8 @@ Status CaseOpLabelMaker::Run(uint32_t &label_index) {
parent_node_->GetName() + "/StreamActive_" + std::to_string(index); // rtStreamActive
NodePtr stream_active = AddStreamActive(graph, stream_active_name);
if (stream_active == nullptr) {
REPORT_CALL_ERROR("E19999", "Add StreamActive node in graph:%s fail when %s",
graph->GetName().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "Subgraph: %s add stream active failed.", graph->GetName().c_str());
return FAILED;
}
@ -75,6 +79,8 @@ Status CaseOpLabelMaker::Run(uint32_t &label_index) {
std::string label_set_name = parent_node_->GetName() + "/LabelSet_" + std::to_string(index); // rtLabelSet
NodePtr label = AddLabelSetEnter(graph, label_set_name, curr_label_index, stream_active);
if (label == nullptr) {
REPORT_CALL_ERROR("E19999", "Add LabelSetEnter node in graph:%s fail when %s",
graph->GetName().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "Subgraph: %s add label set failed.", graph->GetName().c_str());
return FAILED;
}
@ -88,6 +94,8 @@ Status CaseOpLabelMaker::Run(uint32_t &label_index) {
// middle node, add goto node to tail.
std::string label_goto_name = parent_node_->GetName() + "/LabelGoto_" + std::to_string(index); // rtLabelGoto
if (AddLabelGotoLeave(graph, label_goto_name, last_label_index) == nullptr) {
REPORT_CALL_ERROR("E19999", "Add LabelGotoLeave node in graph:%s fail when %s",
graph->GetName().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "Subgraph: %s add label goto failed.", graph->GetName().c_str());
return FAILED;
}
@ -95,6 +103,8 @@ Status CaseOpLabelMaker::Run(uint32_t &label_index) {
// last node, add label node to tail.
std::string last_label_name = parent_node_->GetName() + "/LabelSet_Last"; // rtLabelSet
if (AddLabelSetLeave(graph, last_label_name, last_label_index) == nullptr) {
REPORT_CALL_ERROR("E19999", "Add LabelSetLeave node in graph:%s fail when %s",
graph->GetName().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "Subgraph: %s add label set failed.", graph->GetName().c_str());
return FAILED;
}
@ -110,12 +120,16 @@ Status CaseOpLabelMaker::Run(uint32_t &label_index) {
const GeTensorDesc &pred_desc = case_desc->GetInputDesc(kCasePredIndex);
NodePtr switch_node = AddLabelSwitchEnter(first_graph, label_switch_name, pred_desc, switch_labels);
if (switch_node == nullptr) {
REPORT_CALL_ERROR("E19999", "Add LabelSwitchEnter node in graph:%s fail when %s",
first_graph->GetName().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "Subgraph: %s add label switch failed.", first_graph->GetName().c_str());
return FAILED;
}
// Link control edge to then branch head.
if (GraphUtils::AddEdge(switch_node->GetOutControlAnchor(), first_label->GetInControlAnchor()) != SUCCESS) {
REPORT_CALL_ERROR("E19999", "Add ctrl edge from %s to %s in graph:%s fail when %s", switch_node->GetName().c_str(),
first_label->GetName().c_str(), first_graph->GetName().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "LabelSwitchByIndex: Add ctrl edge to %s failed.", first_label->GetName().c_str());
return FAILED;
}
@ -123,6 +137,8 @@ Status CaseOpLabelMaker::Run(uint32_t &label_index) {
uint32_t parent_index = 0; // Case cond input is first.
const std::string data_name = parent_node_->GetName() + "/SwitchIndexData";
if (AddLabelSwitchIndex(first_graph, data_name, pred_desc, switch_node, parent_index) == nullptr) {
REPORT_CALL_ERROR("E19999", "Add LabelSwitchIndex node in graph:%s fail when %s",
first_graph->GetName().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "Subgraph: %s add switch input failed.", first_graph->GetName().c_str());
return FAILED;
}

22
ge/graph/label/if_label_maker.cc
Unescape View File

@ -43,6 +43,10 @@ Status IfOpLabelMaker::Run(uint32_t &label_index) {
const std::string then_branch_name = if_desc->GetSubgraphInstanceName(kThenBranchIndex);
const std::string else_branch_name = if_desc->GetSubgraphInstanceName(kElseBranchIndex);
if (then_branch_name.empty() || else_branch_name.empty()) {
REPORT_INNER_ERROR("E19999", "Node:%s(%s), check subgraph invalid, "
"then branch graph: %s, else branch graph: %s, when %s",
if_desc->GetName().c_str(), if_desc->GetType().c_str(),
then_branch_name.c_str(), else_branch_name.c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "Node: %s has invalid subgraph, then branch: %s, else branch: %s.",
if_desc->GetName().c_str(), then_branch_name.c_str(), else_branch_name.c_str());
return FAILED;
@ -66,32 +70,44 @@ Status IfOpLabelMaker::Run(uint32_t &label_index) {
NodePtr then_stream_active = AddStreamActive(then_sub_graph, then_active_name);
if (then_stream_active == nullptr) {
REPORT_CALL_ERROR("E19999", "Add StreamActive node in graph:%s fail when %s",
then_sub_graph->GetName().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "Subgraph: %s add stream active failed.", then_sub_graph->GetName().c_str());
return FAILED;
}
NodePtr then_enter_label = AddLabelSetEnter(then_sub_graph, then_label_name, then_enter_index, then_stream_active);
if (then_enter_label == nullptr) {
REPORT_CALL_ERROR("E19999", "Add LabelSetEnter node in graph:%s fail when %s",
then_sub_graph->GetName().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "Subgraph: %s add label set failed.", then_sub_graph->GetName().c_str());
return FAILED;
}
if (AddLabelGotoLeave(then_sub_graph, then_leave_name, else_leave_index) == nullptr) {
REPORT_CALL_ERROR("E19999", "Add LabelGotoLeave node in graph:%s fail when %s",
then_sub_graph->GetName().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "Subgraph: %s add label goto failed.", then_sub_graph->GetName().c_str());
return FAILED;
}
NodePtr else_stream_active = AddStreamActive(else_sub_graph, else_active_name);
if (else_stream_active == nullptr) {
REPORT_CALL_ERROR("E19999", "Add StreamActive node in graph:%s fail when %s",
else_stream_active->GetName().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "Subgraph: %s add stream active failed.", else_sub_graph->GetName().c_str());
return FAILED;
}
if (AddLabelSetEnter(else_sub_graph, else_enter_name, else_enter_index, else_stream_active) == nullptr) {
REPORT_CALL_ERROR("E19999", "Add LabelSetEnter node in graph:%s fail when %s",
else_sub_graph->GetName().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "Subgraph: %s add label set failed.", else_sub_graph->GetName().c_str());
return FAILED;
}
if (AddLabelSetLeave(else_sub_graph, else_leave_name, else_leave_index) == nullptr) {
REPORT_CALL_ERROR("E19999", "Add LabelSetLeave node in graph:%s fail when %s",
else_sub_graph->GetName().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "Subgraph: %s add label set failed.", else_sub_graph->GetName().c_str());
return FAILED;
}
@ -103,12 +119,16 @@ Status IfOpLabelMaker::Run(uint32_t &label_index) {
const GeTensorDesc &pred_desc = if_desc->GetInputDesc(kIfPredIndex);
NodePtr switch_node = AddLabelSwitchEnter(then_sub_graph, then_enter_name, pred_desc, switch_labels);
if (switch_node == nullptr) {
REPORT_CALL_ERROR("E19999", "Add LabelSwitchEnter node in graph:%s fail when %s",
then_sub_graph->GetName().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "Subgraph: %s add label switch failed.", then_sub_graph->GetName().c_str());
return FAILED;
}
// Link control edge to then branch head.
if (GraphUtils::AddEdge(switch_node->GetOutControlAnchor(), then_enter_label->GetInControlAnchor()) != SUCCESS) {
REPORT_CALL_ERROR("E19999", "Add ctrl edge from %s to %s in graph:%s fail when %s", switch_node->GetName().c_str(),
then_enter_label->GetName().c_str(), then_sub_graph->GetName().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "LabelSwitchByIndex: Add ctrl edge to %s failed.", then_enter_label->GetName().c_str());
return FAILED;
}
@ -116,6 +136,8 @@ Status IfOpLabelMaker::Run(uint32_t &label_index) {
uint32_t parent_index = 0; // If cond input is first.
const std::string data_name = parent_node_->GetName() + "/SwitchIndexData";
if (AddLabelSwitchIndex(then_sub_graph, data_name, pred_desc, switch_node, parent_index) == nullptr) {
REPORT_CALL_ERROR("E19999", "Add LabelSwitchIndex node in graph:%s fail when %s",
then_sub_graph->GetName().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "Subgraph: %s add switch input failed.", then_sub_graph->GetName().c_str());
return FAILED;
}

30
ge/graph/label/label_maker.cc
Unescape View File

@ -56,6 +56,8 @@ void LabelMaker::LinkToGraphHead(const ComputeGraphPtr &graph, const NodePtr &no
}
if (GraphUtils::AddEdge(node->GetOutControlAnchor(), n->GetInControlAnchor()) != SUCCESS) {
REPORT_CALL_ERROR("E19999", "Add ctrl edge from %s to %s in graph:%s fail when %s", node->GetName().c_str(),
n->GetName().c_str(), graph->GetName().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "Add ctrl edge from %s to %s failed.", node->GetName().c_str(), n->GetName().c_str());
}
}
@ -78,6 +80,8 @@ void LabelMaker::LinkToGraphTail(const ComputeGraphPtr &graph, const NodePtr &no
}
if (GraphUtils::AddEdge(tail->GetOutControlAnchor(), node->GetInControlAnchor()) != SUCCESS) {
REPORT_CALL_ERROR("E19999", "Add ctrl edge from %s to %s in graph:%s fail when %s", tail->GetName().c_str(),
node->GetName().c_str(), graph->GetName().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "Add ctrl edge from %s to %s failed.", tail->GetName().c_str(), node->GetName().c_str());
}
return;
@ -96,6 +100,7 @@ NodePtr LabelMaker::AddStreamActive(const ComputeGraphPtr &graph, const std::str
const auto &node_list = graph->GetDirectNode();
if (node_list.empty()) {
REPORT_INNER_ERROR("E19999", "Check param graph has no node when %s", graph->GetName().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "LabelSet: Graph %s node is empty.", graph->GetName().c_str());
return nullptr;
}
@ -131,6 +136,7 @@ NodePtr LabelMaker::AddLabelSetEnter(const ComputeGraphPtr &graph, const std::st
const auto &node_list = graph->GetDirectNode();
if (node_list.empty()) {
REPORT_INNER_ERROR("E19999", "Check param graph has no node when %s", graph->GetName().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "LabelSet: Graph %s node is empty.", graph->GetName().c_str());
return nullptr;
}
@ -145,6 +151,8 @@ NodePtr LabelMaker::AddLabelSetEnter(const ComputeGraphPtr &graph, const std::st
GE_CHECK_NOTNULL_EXEC(label_set, return nullptr);
if (GraphUtils::AddEdge(label_set->GetOutControlAnchor(), stream_active->GetInControlAnchor()) != SUCCESS) {
REPORT_CALL_ERROR("E19999", "Add ctrl edge from %s to %s in graph:%s fail when %s", label_set->GetName().c_str(),
stream_active->GetName().c_str(), graph->GetName().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "Add ctrl edge from %s to %s failed.", label_set->GetName().c_str(),
stream_active->GetName().c_str());
return nullptr;
@ -193,6 +201,7 @@ NodePtr LabelMaker::AddLabelGotoEnter(const ComputeGraphPtr &graph, const std::s
const auto &node_list = graph->GetDirectNode();
auto it = node_list.begin();
if (it == node_list.end()) {
REPORT_INNER_ERROR("E19999", "Check param graph has no node when %s", graph->GetName().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "LabelGoto: Graph %s node is empty.", graph->GetName().c_str());
return nullptr;
}
@ -205,6 +214,8 @@ NodePtr LabelMaker::AddLabelGotoEnter(const ComputeGraphPtr &graph, const std::s
(void)AttrUtils::SetInt(op_desc, ATTR_NAME_LABEL_SWITCH_INDEX, index);
NodePtr label_goto = graph->AddNodeFront(op_desc);
if (label_goto == nullptr) {
REPORT_CALL_ERROR("E19999", "Add node:%s(%s) to graph:%s fail when %s",
op_desc->GetName().c_str(), op_desc->GetType().c_str(), graph->GetName().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "LabelGoto: Add to graph %s failed.", graph->GetName().c_str());
return nullptr;
}
@ -253,6 +264,7 @@ NodePtr LabelMaker::AddLabelSwitchEnter(const ComputeGraphPtr &graph, const std:
const auto &node_list = graph->GetDirectNode();
auto it = node_list.begin();
if (it == node_list.end()) {
REPORT_INNER_ERROR("E19999", "Check param graph has no node when %s", graph->GetName().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "LabelSwitchByIndex: Graph %s node is empty.", graph->GetName().c_str());
return nullptr;
}
@ -263,17 +275,23 @@ NodePtr LabelMaker::AddLabelSwitchEnter(const ComputeGraphPtr &graph, const std:
GELOGI("LabelSwitchByIndex: Create node %s.", op_desc->GetName().c_str());
if (op_desc->AddInputDesc(desc) != GRAPH_SUCCESS) {
REPORT_CALL_ERROR("E19999", "Add input desc into node:%s(%s) in graph:%s fail when %s",
op_desc->GetName().c_str(), op_desc->GetType().c_str(), graph->GetName().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "LabelSwitchByIndex: Add input desc failed.");
return nullptr;
}
if (!AttrUtils::SetListInt(op_desc, ATTR_NAME_LABEL_SWITCH_LIST, labels)) {
REPORT_INNER_ERROR("E19999", "Set Attr:%s fail for op:%s(%s) when %s", ATTR_NAME_LABEL_SWITCH_LIST.c_str(),
op_desc->GetName().c_str(), op_desc->GetType().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "LabelSwitchByIndex: Add %s failed.", ATTR_NAME_LABEL_SWITCH_INDEX.c_str());
return nullptr;
}
NodePtr label_switch = graph->AddNodeFront(op_desc);
if (label_switch == nullptr) {
REPORT_CALL_ERROR("E19999", "Add node:%s(%s) to graph:%s ahead fail when %s",
op_desc->GetName().c_str(), op_desc->GetType().c_str(), graph->GetName().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "LabelSwitchByIndex: Add to graph %s failed.", graph->GetName().c_str());
return nullptr;
}
@ -300,11 +318,15 @@ NodePtr LabelMaker::AddLabelSwitchLeave(const ComputeGraphPtr &graph, const std:
GELOGI("LabelSwitchByIndex: Create node %s.", op_desc->GetName().c_str());
if (op_desc->AddInputDesc(desc) != GRAPH_SUCCESS) {
REPORT_CALL_ERROR("E19999", "Add input desc into node:%s(%s) in graph:%s fail when %s",
op_desc->GetName().c_str(), op_desc->GetType().c_str(), graph->GetName().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "LabelSwitchByIndex: Add input desc failed.");
return nullptr;
}
if (!AttrUtils::SetListInt(op_desc, ATTR_NAME_LABEL_SWITCH_LIST, labels)) {
REPORT_INNER_ERROR("E19999", "Set Attr:%s fail for op:%s(%s) when %s", ATTR_NAME_LABEL_SWITCH_LIST.c_str(),
op_desc->GetName().c_str(), op_desc->GetType().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "LabelSwitchByIndex: Add %s failed.", ATTR_NAME_LABEL_SWITCH_INDEX.c_str());
return nullptr;
}
@ -336,15 +358,21 @@ NodePtr LabelMaker::AddLabelSwitchIndex(const ComputeGraphPtr &graph, const std:
GELOGI("Data: Create node %s.", op_desc->GetName().c_str());
if (op_desc->AddInputDesc(desc) != GRAPH_SUCCESS) {
REPORT_CALL_ERROR("E19999", "Add input desc into node:%s(%s) in graph:%s fail when %s",
op_desc->GetName().c_str(), op_desc->GetType().c_str(), graph->GetName().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "LabelSwitchByIndex: Add data input desc failed.");
return nullptr;
}
if (op_desc->AddOutputDesc(desc) != GRAPH_SUCCESS) {
REPORT_CALL_ERROR("E19999", "Add output desc into node:%s(%s) in graph:%s fail when %s",
op_desc->GetName().c_str(), op_desc->GetType().c_str(), graph->GetName().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "LabelSwitchByIndex: Add data output desc failed.");
return nullptr;
}
if (!AttrUtils::SetInt(op_desc, ATTR_NAME_PARENT_NODE_INDEX, parent_index)) {
REPORT_INNER_ERROR("E19999", "Set Attr:%s fail for op:%s(%s) when %s", ATTR_NAME_PARENT_NODE_INDEX.c_str(),
op_desc->GetName().c_str(), op_desc->GetType().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "LabelSwitchByIndex: Add %s failed.", ATTR_NAME_PARENT_NODE_INDEX.c_str());
return nullptr;
}
@ -354,6 +382,8 @@ NodePtr LabelMaker::AddLabelSwitchIndex(const ComputeGraphPtr &graph, const std:
// Link control edge to graph head.
if (GraphUtils::AddEdge(op_data->GetOutDataAnchor(0), sw_node->GetInDataAnchor(0)) != SUCCESS) {
REPORT_CALL_ERROR("E19999", "Add ctrl edge from %s to %s in graph:%s fail when %s", op_data->GetName().c_str(),
sw_node->GetName().c_str(), graph->GetName().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "LabelSwitchByIndex: Add input edge to %s failed.", op_data->GetName().c_str());
return nullptr;
}

7
ge/graph/label/partitioned_call_label_maker.cc
Unescape View File

@ -39,12 +39,17 @@ Status PartitionedCallLabelMaker::Run(uint32_t &label_index) {
std::string sub_graph_name = call_desc->GetSubgraphInstanceName(kSubGraphIndex);
if (sub_graph_name.empty()) {
REPORT_INNER_ERROR("E19999", "Node:%s(%s) subgraph_index:%d name is empty, check invalid when %s",
call_desc->GetName().c_str(), call_desc->GetType().c_str(), kSubGraphIndex, __FUNCTION__);
GELOGE(INTERNAL_ERROR, "Node: %s has no subgraph name.", sub_graph_name.c_str());
return FAILED;
}
ComputeGraphPtr sub_graph = parent_graph_->GetSubgraph(sub_graph_name);
if (sub_graph == nullptr) {
REPORT_INNER_ERROR("E19999", "Node:%s(%s) subgraph_name:%s is not exist in parent_graph, check invalid when %s",
call_desc->GetName().c_str(), call_desc->GetType().c_str(),
sub_graph_name.c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "Node: %s has no subgraph.", sub_graph_name.c_str());
return FAILED;
}
@ -52,6 +57,8 @@ Status PartitionedCallLabelMaker::Run(uint32_t &label_index) {
const std::string stream_active_name = parent_node_->GetName() + "/StreamActive"; // rtStreamActive
NodePtr stream_active = AddStreamActive(sub_graph, stream_active_name);
if (stream_active == nullptr) {
REPORT_CALL_ERROR("E19999", "Add StreamActive node in graph:%s fail when %s",
sub_graph->GetName().c_str(), __FUNCTION__);
GELOGE(INTERNAL_ERROR, "Subgraph: %s add stream active node failed.", sub_graph->GetName().c_str());
return FAILED;
}

Some files were not shown because too many files have changed in this diff Show More

Write Preview
Loading…
Cancel
Save