diff --git a/mindspore/lite/tools/anf_exporter/fetch_content.cc b/mindspore/lite/tools/anf_exporter/fetch_content.cc index d692765e27d..e63ac3a3e83 100644 --- a/mindspore/lite/tools/anf_exporter/fetch_content.cc +++ b/mindspore/lite/tools/anf_exporter/fetch_content.cc @@ -58,11 +58,19 @@ STATUS GetShapeVectorFromStringTensor(const tensor::TensorPtr &tensor_info, Shap MS_LOG(ERROR) << "string tensor's dim size not found."; return RET_ERROR; } - size_t shape_size = std::stoi(shape_size_str); + size_t shape_size = std::atoi(shape_size_str.c_str()); + MS_CHECK_TRUE_RET(shape_size != 0, RET_ERROR); for (; *offset < tensor_info->Size(); (*offset)++) { if (tensor_data[*offset] == ',') { cnt++; - shape_vector->push_back(std::stoi(shape_str)); + int64_t shape = 0; + try { + shape = std::stoi(shape_str); + } catch (const std::exception &e) { + MS_LOG(ERROR) << "Get shape failed: " << e.what(); + return RET_ERROR; + } + shape_vector->push_back(shape); shape_str.clear(); } else { shape_str.push_back(tensor_data[*offset]); diff --git a/mindspore/lite/tools/converter/converter_flags.cc b/mindspore/lite/tools/converter/converter_flags.cc index 703c84b4216..b4ca2f30fcd 100644 --- a/mindspore/lite/tools/converter/converter_flags.cc +++ b/mindspore/lite/tools/converter/converter_flags.cc @@ -197,11 +197,18 @@ int Flags::InitInTensorShape() { return lite::RET_ERROR; } for (const auto &dim : dims) { - if (std::stoi(dim) < 0) { + auto dim_value = -1; + try { + dim_value = std::stoi(dim); + } catch (const std::exception &e) { + MS_LOG(ERROR) << "Get dim failed: " << e.what(); + return lite::RET_ERROR; + } + if (dim_value < 0) { MS_LOG(ERROR) << "Unsupported dim < 0."; return lite::RET_ERROR; } else { - shape.push_back(std::stoi(dim)); + shape.push_back(dim_value); } } lite::ConverterInnerContext::GetInstance()->UpdateGraphInputTensorShape(name, shape); @@ -419,7 +426,12 @@ bool CheckOfflineParallelConfig(const std::string &file, ParallelSplitConfig *pa const char *colon = ":"; for (const auto &device : device_rates) { std::vector rate = lite::SplitStringToVector(device, *colon); - parallel_split_config->parallel_compute_rates_.push_back(std::stoi(rate.back())); + auto compute_rate = std::atoi(rate.back().c_str()); + if (compute_rate == 0) { + MS_LOG(ERROR) << "The compute rate is invalid."; + return false; + } + parallel_split_config->parallel_compute_rates_.push_back(compute_rate); } if (parallel_split_config->parallel_compute_rates_.size() != 2) { return false; diff --git a/mindspore/lite/tools/converter/ops/while.cc b/mindspore/lite/tools/converter/ops/while.cc index 76f40f3acdf..8289e16feb2 100644 --- a/mindspore/lite/tools/converter/ops/while.cc +++ b/mindspore/lite/tools/converter/ops/while.cc @@ -67,7 +67,7 @@ AbstractBasePtr WhileInfer(const abstract::AnalysisEnginePtr &, const PrimitiveP auto while_prim = primitive->cast(); MS_CHECK_TRUE_RET(while_prim != nullptr, nullptr); AbstractBasePtrList output; - for (int64_t i = 0; i < (int64_t)input_args.size(); i++) { + for (size_t i = 0; i < input_args.size(); i++) { auto build_shape_ptr = input_args[i]->BuildShape(); MS_CHECK_TRUE_RET(build_shape_ptr != nullptr, nullptr); auto shape = CheckAndConvertUtils::ConvertShapePtrToShapeMap(build_shape_ptr)[kShape]; diff --git a/mindspore/lite/tools/converter/preprocess/image_preprocess.cc b/mindspore/lite/tools/converter/preprocess/image_preprocess.cc index 8e832b4a16f..b9eda2d8a37 100644 --- a/mindspore/lite/tools/converter/preprocess/image_preprocess.cc +++ b/mindspore/lite/tools/converter/preprocess/image_preprocess.cc @@ -116,7 +116,7 @@ int CenterCrop(cv::Mat *image, int width, int height) { } int PreProcess(const preprocess::DataPreProcessParam &data_pre_process_param, const std::string &input_name, - int image_index, mindspore::tensor::MSTensor *tensor) { + size_t image_index, mindspore::tensor::MSTensor *tensor) { if (tensor == nullptr) { MS_LOG(ERROR) << "tensor is nullptr."; return RET_NULL_PTR; @@ -155,7 +155,7 @@ int PreProcess(const preprocess::DataPreProcessParam &data_pre_process_param, co return RET_OK; } -int PreProcess(const DataPreProcessParam &data_pre_process_param, const std::string &input_name, int image_index, +int PreProcess(const DataPreProcessParam &data_pre_process_param, const std::string &input_name, size_t image_index, void **data, size_t *size) { if (data == nullptr || size == nullptr) { MS_LOG(ERROR) << "data or size is nullptr."; diff --git a/mindspore/lite/tools/converter/preprocess/image_preprocess.h b/mindspore/lite/tools/converter/preprocess/image_preprocess.h index e360cdcd545..84c219bc614 100644 --- a/mindspore/lite/tools/converter/preprocess/image_preprocess.h +++ b/mindspore/lite/tools/converter/preprocess/image_preprocess.h @@ -35,11 +35,11 @@ int Resize(cv::Mat *image, int width, int height, cv::InterpolationFlags resize_ int CenterCrop(cv::Mat *image, int width, int height); // NOTE:`data` must be use delete[] to free buffer. -int PreProcess(const DataPreProcessParam &data_pre_process_param, const std::string &input_name, int image_index, +int PreProcess(const DataPreProcessParam &data_pre_process_param, const std::string &input_name, size_t image_index, void **data, size_t *size); int PreProcess(const preprocess::DataPreProcessParam &data_pre_process_param, const std::string &input_name, - int image_index, mindspore::tensor::MSTensor *tensor); + size_t image_index, mindspore::tensor::MSTensor *tensor); int ImagePreProcess(const ImagePreProcessParam &image_preprocess_param, cv::Mat *image, void **data, size_t *size); diff --git a/mindspore/lite/tools/optimizer/fisson/eliminate_concat_split.cc b/mindspore/lite/tools/optimizer/fisson/eliminate_concat_split.cc index e4f9f548746..f6ff90713d2 100644 --- a/mindspore/lite/tools/optimizer/fisson/eliminate_concat_split.cc +++ b/mindspore/lite/tools/optimizer/fisson/eliminate_concat_split.cc @@ -64,7 +64,7 @@ int ConcatSplitEliminate(const FuncGraphPtr &func_graph, const CNodePtr &cnode) Spliter::GetInstance()->graph_node_outputs(); auto finder = graph_node_outputs.find(pre_cnode->fullname_with_scope()); if (finder == graph_node_outputs.end()) { - return RET_OK; + return RET_ERROR; } if (finder->second.size() > 1) { return RET_OK; @@ -89,7 +89,7 @@ int ConcatSplitEliminate(const FuncGraphPtr &func_graph, const CNodePtr &cnode) // get inputs node auto it = graph_node_outputs.find(cnode->fullname_with_scope()); if (it == graph_node_outputs.end()) { - return RET_OK; + return RET_ERROR; } int out_num = it->second.size(); if (out_num != prim->get_number_split()) { @@ -101,14 +101,14 @@ int ConcatSplitEliminate(const FuncGraphPtr &func_graph, const CNodePtr &cnode) auto tmp = it->second[i]; auto tmp_cnode = tmp->cast(); if (tmp_cnode == nullptr) { - return RET_OK; + return RET_ERROR; } if (!CheckPrimitiveType(tmp_cnode, prim::kPrimTupleGetItem)) { return RET_OK; } auto tmp_it = graph_node_outputs.find(tmp_cnode->fullname_with_scope()); if (tmp_it == graph_node_outputs.end()) { - return RET_OK; + return RET_ERROR; } if (tmp_it->second.size() != 1) { return RET_OK; @@ -116,7 +116,7 @@ int ConcatSplitEliminate(const FuncGraphPtr &func_graph, const CNodePtr &cnode) auto next = tmp_it->second[0]; auto next_cnode = next->cast(); - + MS_ASSERT(next_cnode != nullptr); inputs_node.push_back(next_cnode); } // replace inputs diff --git a/mindspore/lite/tools/optimizer/fisson/fisson_util.cc b/mindspore/lite/tools/optimizer/fisson/fisson_util.cc index b736f79826b..04576056db0 100644 --- a/mindspore/lite/tools/optimizer/fisson/fisson_util.cc +++ b/mindspore/lite/tools/optimizer/fisson/fisson_util.cc @@ -48,14 +48,21 @@ std::vector GetSplitPadList(const std::shared_ptr &o int64_t output_w = static_cast( std::ceil(static_cast(input_w) / static_cast(ori_conv_prim->get_stride().at(kIndexW)))); + auto kernel_h = ori_conv_prim->get_kernel_size().at(kIndexH); + auto dilation_h = ori_conv_prim->get_dilation().at(kIndexH); + auto kernel_w = ori_conv_prim->get_kernel_size().at(kIndexW); + auto dilation_w = ori_conv_prim->get_dilation().at(kIndexW); + if (INT_MUL_OVERFLOW_THRESHOLD((kernel_h - 1), dilation_h, INT64_MAX) || + INT_MUL_OVERFLOW_THRESHOLD((kernel_w - 1), dilation_w, INT64_MAX)) { + MS_LOG(ERROR) << "int mul overflow"; + return {}; + } std::vector new_pad_list; int64_t pad_up = 0, pad_down = 0, pad_left = 0, pad_right = 0; - int64_t pad_h_all = (output_h - 1) * ori_conv_prim->get_stride().at(kIndexH) + - (ori_conv_prim->get_kernel_size().at(kIndexH) - 1) * ori_conv_prim->get_dilation().at(kIndexH) + - 1 - input_h; - int64_t pad_w_all = (output_w - 1) * ori_conv_prim->get_stride().at(kIndexW) + - (ori_conv_prim->get_kernel_size().at(kIndexW) - 1) * ori_conv_prim->get_dilation().at(kIndexW) + - 1 - input_w; + int64_t pad_h_all = + (output_h - 1) * ori_conv_prim->get_stride().at(kIndexH) + (kernel_h - 1) * dilation_h + 1 - input_h; + int64_t pad_w_all = + (output_w - 1) * ori_conv_prim->get_stride().at(kIndexW) + (kernel_w - 1) * dilation_w + 1 - input_w; // only check pad_up and pad_down is positive // if compute overflowed, we will get abnormal it in infer_shape if (pad_h_all >= 0) { @@ -110,9 +117,11 @@ bool CalSplitInShape(const std::vector> &node_in_out_sh const std::shared_ptr &ori_conv_prim, int64_t index_node, std::vector> *split_axis_inputs_shape, std::vector> *split_axis_reduce_inputs_shape) { - MS_ASSERT(split_info != nullptr && split_axis_inputs_shape != nullptr && split_axis_reduce_inputs_shape != nullptr); + MS_ASSERT(split_info != nullptr && ori_conv_prim != nullptr && split_axis_inputs_shape != nullptr && + split_axis_reduce_inputs_shape != nullptr); MS_ASSERT(node_in_out_shapes.size() > index_node); auto in_out_shape = node_in_out_shapes.at(index_node); + MS_ASSERT(!in_out_shape.empty()); auto in_shape = in_out_shape.front(); if (in_shape.size() < kAxisW) { MS_LOG(DEBUG) << "out of in_shape range"; @@ -129,29 +138,34 @@ bool CalSplitInShape(const std::vector> &node_in_out_sh // iter splited_num for (int64_t index = 0; index < split_num; index++) { // shape + auto stride_h = ori_conv_prim->get_stride()[kIndexH]; + auto split_axis_dim = (*split_axis_inputs_shape)[index_node][index] - 1; + if (INT_MUL_OVERFLOW_THRESHOLD(stride_h, split_axis_dim, INT64_MAX)) { + MS_LOG(ERROR) << "int mul overflow"; + return false; + } if (split_info->axis == CuttingStragedy::CUT_H) { // H if (index == 0) { - tmp = ori_conv_prim->get_stride()[kIndexH] * ((*split_axis_inputs_shape)[index_node][index] - 1) - - ori_conv_prim->get_pad_list()[kPadUp] + ori_conv_prim->get_kernel_size()[kIndexH]; + tmp = + stride_h * split_axis_dim - ori_conv_prim->get_pad_list()[kPadUp] + ori_conv_prim->get_kernel_size()[kIndexH]; } else if (index == split_num - 1) { - tmp = ori_conv_prim->get_stride()[kIndexH] * ((*split_axis_inputs_shape)[index_node][index] - 1) - - ori_conv_prim->get_pad_list()[kPadDown] + ori_conv_prim->get_kernel_size()[kIndexH]; - } else { - tmp = ori_conv_prim->get_stride()[kIndexH] * ((*split_axis_inputs_shape)[index_node][index] - 1) - 0 + + tmp = stride_h * split_axis_dim - ori_conv_prim->get_pad_list()[kPadDown] + ori_conv_prim->get_kernel_size()[kIndexH]; + } else { + tmp = stride_h * split_axis_dim - 0 + ori_conv_prim->get_kernel_size()[kIndexH]; } } split_axis_shape.push_back(tmp); // reduce shape + auto split_axis_reduce_dim = (*split_axis_reduce_inputs_shape)[index_node][index] - 1; if (split_info->axis == CuttingStragedy::CUT_H) { // H if (index == split_num - 1) { - tmp = ori_conv_prim->get_stride()[kIndexH] * ((*split_axis_reduce_inputs_shape)[index_node][index] - 1) - - ori_conv_prim->get_pad_list()[kPadDown] - ori_conv_prim->get_pad_list()[kPadUp] + - ori_conv_prim->get_kernel_size()[kIndexH]; - } else { - tmp = ori_conv_prim->get_stride()[kIndexH] * ((*split_axis_reduce_inputs_shape)[index_node][index] - 1) - + tmp = stride_h * split_axis_reduce_dim - ori_conv_prim->get_pad_list()[kPadDown] - ori_conv_prim->get_pad_list()[kPadUp] + ori_conv_prim->get_kernel_size()[kIndexH]; + } else { + tmp = stride_h * split_axis_reduce_dim - ori_conv_prim->get_pad_list()[kPadUp] + + ori_conv_prim->get_kernel_size()[kIndexH]; } } split_axis_reduce_shape.push_back(tmp); @@ -186,9 +200,8 @@ std::shared_ptr CopyConvPrim(const std::shared_ptrset_stride(ori_conv_prim->get_stride()); new_prim->set_activation_type(ori_conv_prim->get_activation_type()); new_prim->set_pad_list(ori_conv_prim->get_pad_list()); - if (ori_conv_prim->GetAttr(ops::kIsDepthWise) != nullptr) { - auto is_depth_value = ori_conv_prim->GetAttr(ops::kIsDepthWise); - MS_CHECK_TRUE_MSG(is_depth_value != nullptr, nullptr, "conv has no kIsDepthWise attribute"); + auto is_depth_value = ori_conv_prim->GetAttr(ops::kIsDepthWise); + if (is_depth_value != nullptr) { bool is_depth_wise = GetValue(is_depth_value); new_prim->AddAttr(ops::kIsDepthWise, MakeValue(is_depth_wise)); } @@ -218,6 +231,7 @@ bool UpdateSplitInfo(const FuncGraphPtr &func_graph, const std::vectorgraph_node_input_shapes()[out_node_name]; // 0-> in-shape 1->out-shape // only one in and one output + MS_ASSERT(!input_shapes.empty() && !output_shapes.empty()); node_in_out_shapes.push_back({input_shapes.front(), output_shapes.front()}); index_node++; } @@ -244,7 +258,9 @@ bool UpdateSplitInfo(const FuncGraphPtr &func_graph, const std::vectorcast(); + MS_ASSERT(conv_cnode != nullptr); auto ori_conv_prim = GetValueNode>(conv_cnode->input(kAnfPrimitiveIndex)); + MS_CHECK_TRUE_RET(ori_conv_prim != nullptr, false); if (!CalSplitInShape(node_in_out_shapes, split_info, ori_conv_prim, index_node, &split_axis_inputs_shape, &split_axis_reduce_inputs_shape)) { MS_LOG(ERROR) << "CalSplitInShape failed"; @@ -405,6 +421,10 @@ bool UpdateRatioWithPadStride(int64_t *ratio, size_t ratio_len, size_t split_siz int visited_block = 0; for (size_t i = 0; i < split_size - 1; i++) { visited_block += ratio[i]; + if (INT_MUL_OVERFLOW_THRESHOLD(split_dim_size, visited_block, INT64_MAX)) { + MS_LOG(ERROR) << "int mul overflow"; + return false; + } int cur_border = UP_DIV(split_dim_size * visited_block, total_block_count); new_ratio[i + 1] = cur_border; } diff --git a/mindspore/lite/tools/optimizer/fisson/iter_node_outputs.cc b/mindspore/lite/tools/optimizer/fisson/iter_node_outputs.cc index db5fbd88e53..9f46afcd778 100644 --- a/mindspore/lite/tools/optimizer/fisson/iter_node_outputs.cc +++ b/mindspore/lite/tools/optimizer/fisson/iter_node_outputs.cc @@ -30,6 +30,7 @@ AnfNodePtr IterNodeOutputs::Run(const FuncGraphPtr &func_graph, const AnfNodePtr auto inputs = cnode->inputs(); for (const auto &input_node : inputs) { + MS_ASSERT(input_node != nullptr); if (!utils::isa(input_node)) { continue; } diff --git a/mindspore/lite/tools/optimizer/fisson/multi_conv_split_pass.cc b/mindspore/lite/tools/optimizer/fisson/multi_conv_split_pass.cc index c0fa8a429c2..a5ba4ad65e3 100644 --- a/mindspore/lite/tools/optimizer/fisson/multi_conv_split_pass.cc +++ b/mindspore/lite/tools/optimizer/fisson/multi_conv_split_pass.cc @@ -29,6 +29,7 @@ using mindspore::schema::PrimitiveType_Conv2dTransposeFusion; namespace mindspore { namespace opt { std::string MultiConvSplitPass::IsMultiParallelConvNode(const AnfNodePtr &node) const { + MS_ASSERT(node != nullptr); for (const auto ¶llel_prim : kParallelOpNames) { if (CheckPrimitiveType(node, parallel_prim.first.first)) { return parallel_prim.second; diff --git a/mindspore/lite/tools/optimizer/fisson/node_out_shapes.cc b/mindspore/lite/tools/optimizer/fisson/node_out_shapes.cc index 1ab778af343..0ae353d6248 100644 --- a/mindspore/lite/tools/optimizer/fisson/node_out_shapes.cc +++ b/mindspore/lite/tools/optimizer/fisson/node_out_shapes.cc @@ -32,6 +32,7 @@ AnfNodePtr NodeOutShapes::Run(const FuncGraphPtr &func_graph, const AnfNodePtr & auto cnode = node->cast(); // assume multi inputs for (const auto &input_node : cnode->inputs()) { + MS_ASSERT(input_node != nullptr); if (utils::isa(input_node) || utils::isa(input_node)) { auto in_shape = input_node->Shape(); if (in_shape == nullptr) { diff --git a/mindspore/lite/tools/optimizer/fusion/conv_biasadd_fusion.cc b/mindspore/lite/tools/optimizer/fusion/conv_biasadd_fusion.cc index 96083067ea9..10f9b8957c2 100644 --- a/mindspore/lite/tools/optimizer/fusion/conv_biasadd_fusion.cc +++ b/mindspore/lite/tools/optimizer/fusion/conv_biasadd_fusion.cc @@ -56,10 +56,10 @@ bool FuseBias(const lite::DataInfo &add_bias, const lite::DataInfo &conv_bias, s add_bias.data_.size()) != EOK) { return false; } - fusion_bias->resize(out_channel, 0); + fusion_bias->resize(static_cast(out_channel), 0); if (!conv_bias.data_.empty()) { if (conv_bias.data_type_ != TypeId::kNumberTypeFloat32 && conv_bias.data_type_ != TypeId::kNumberTypeFloat && - conv_bias.data_.size() != out_channel * sizeof(float)) { + conv_bias.data_.size() != static_cast(out_channel) * sizeof(float)) { return false; } if (memcpy_s(fusion_bias->data(), fusion_bias->size() * sizeof(float), conv_bias.data_.data(), diff --git a/mindspore/lite/tools/optimizer/fusion/conv_pad_fusion.cc b/mindspore/lite/tools/optimizer/fusion/conv_pad_fusion.cc index b7c7329651b..056711cdd77 100644 --- a/mindspore/lite/tools/optimizer/fusion/conv_pad_fusion.cc +++ b/mindspore/lite/tools/optimizer/fusion/conv_pad_fusion.cc @@ -110,8 +110,7 @@ void ReplaceParamsAndNodes(const FuncGraphPtr &func_graph, const CNodePtr &conv_ (void)manager->Replace(pad_cnode, pad_cnode->input(1)); } -bool IsPrimitiveProper(const CNodePtr &conv_cnode, const CNodePtr &pad_cnode) { - MS_ASSERT(conv_cnode != nullptr); +bool IsPrimitiveProper(const CNodePtr &pad_cnode) { MS_ASSERT(pad_cnode != nullptr); if (!utils::isa(pad_cnode->input(kInputIndexTwo))) { return false; @@ -240,7 +239,7 @@ AnfNodePtr ConvPadFusion::Process(const std::string &pattern_name, const FuncGra return nullptr; } - if (!IsPrimitiveProper(conv_cnode, pad_cnode)) { + if (!IsPrimitiveProper(pad_cnode)) { MS_LOG(WARNING) << conv_cnode->fullname_with_scope() << " is not match with previous " << pad_cnode->fullname_with_scope() << " op. Fusion failed!"; return nullptr; diff --git a/mindspore/lite/tools/optimizer/fusion/mul_add_fusion.cc b/mindspore/lite/tools/optimizer/fusion/mul_add_fusion.cc index e60d4bf009c..85eea74b8b6 100644 --- a/mindspore/lite/tools/optimizer/fusion/mul_add_fusion.cc +++ b/mindspore/lite/tools/optimizer/fusion/mul_add_fusion.cc @@ -267,7 +267,7 @@ const AnfNodePtr MulAddFusion::Process(const FuncGraphPtr &func_graph, const Anf return nullptr; } scale_primitive->set_activation_type(scale_act_type_); - scale_primitive->set_axis(-(bias_tensor_->shape_c().size())); + scale_primitive->set_axis(-(static_cast(bias_tensor_->shape_c().size()))); // create scale op auto scale_node = func_graph->NewCNode(scale_primitive, {mul_input_anode_, mul_const_anode_, add_const_anode_}); return scale_node; diff --git a/mindspore/lite/tools/optimizer/fusion/norm_fusion.cc b/mindspore/lite/tools/optimizer/fusion/norm_fusion.cc index c76d2e39b59..17cc593d6e3 100644 --- a/mindspore/lite/tools/optimizer/fusion/norm_fusion.cc +++ b/mindspore/lite/tools/optimizer/fusion/norm_fusion.cc @@ -51,7 +51,8 @@ STATUS GetReduceAxes(const BaseRef &n, std::vector *axes) { } axes->resize(1); if (!axes_value->shape().empty()) { - axes->resize(axes_value->shape()[0]); + MS_CHECK_GE(axes_value->shape()[0], 0, lite::RET_ERROR); + axes->resize(static_cast(axes_value->shape()[0])); } if (memcpy_s(axes->data(), axes->size() * sizeof(int), axes_value->data_c(), axes_value->Size()) == EOK) { return lite::RET_OK; @@ -285,7 +286,8 @@ int ExpandDimsShapeSizeInfer(const std::vector &in_shape_size, const schema int StridedSliceShapeSizeInfer(const std::vector &in_shape_size, const schema::PrimitiveT &primitive) { MS_ASSERT(in_shape_size.size() > 0); - auto new_axis_mask = primitive.value.AsStridedSlice()->new_axis_mask; + MS_ASSERT(primitive.value.AsStridedSlice() != nullptr); + auto new_axis_mask = static_cast(primitive.value.AsStridedSlice()->new_axis_mask); auto add_dims = 0; while (new_axis_mask != 0) { new_axis_mask = (new_axis_mask - 1) & new_axis_mask; @@ -404,7 +406,7 @@ std::map NormFusion::ShapeSizeInfer(const FuncGraphPtr &func_graph) } // Cal shape size infer function auto shape_size_infer_func = shape_size_infer_iter->second; - auto shape_size = shape_size_infer_iter->second(in_shape_sizes, *prim_t); + auto shape_size = shape_size_infer_func(in_shape_sizes, *prim_t); // Update node shape size map node_shape_size[cnode->fullname_with_scope()] = shape_size; } diff --git a/mindspore/lite/tools/optimizer/fusion/tf_bidirection_gru_fusion.cc b/mindspore/lite/tools/optimizer/fusion/tf_bidirection_gru_fusion.cc index 8599d28f269..929584d1204 100644 --- a/mindspore/lite/tools/optimizer/fusion/tf_bidirection_gru_fusion.cc +++ b/mindspore/lite/tools/optimizer/fusion/tf_bidirection_gru_fusion.cc @@ -766,8 +766,8 @@ const AnfNodePtr TfBidirectionGruFusion::Process(const FuncGraphPtr &func_graph, MS_CHECK_TRUE_RET(fw_cond_graph_pattern != nullptr, nullptr); auto fw_cond = utils::cast((*equiv)[fw_vars_[0]]); MS_ASSERT(fw_cond != nullptr); - auto fw_cond_equiv = TfliteLstmCellFusion::CheckSubGraph(func_graph, fw_cond_graph_pattern, fw_cond_primitive_vars, - fw_cond, kCondCNodesNum, kCondNodesNum); + auto fw_cond_equiv = TfliteLstmCellFusion::CheckSubGraph(fw_cond_graph_pattern, fw_cond_primitive_vars, fw_cond, + kCondCNodesNum, kCondNodesNum); if (fw_cond_equiv == nullptr || fw_cond_equiv->empty()) { return nullptr; } @@ -778,8 +778,8 @@ const AnfNodePtr TfBidirectionGruFusion::Process(const FuncGraphPtr &func_graph, MS_CHECK_TRUE_RET(bw_cond_graph_pattern != nullptr, nullptr); auto bw_cond = utils::cast((*equiv)[bw_vars_[0]]); MS_ASSERT(bw_cond != nullptr); - auto bw_cond_equiv = TfliteLstmCellFusion::CheckSubGraph(func_graph, bw_cond_graph_pattern, bw_cond_primitive_vars, - bw_cond, kCondCNodesNum, kCondNodesNum); + auto bw_cond_equiv = TfliteLstmCellFusion::CheckSubGraph(bw_cond_graph_pattern, bw_cond_primitive_vars, bw_cond, + kCondCNodesNum, kCondNodesNum); if (bw_cond_equiv == nullptr || bw_cond_equiv->empty()) { return nullptr; } @@ -790,8 +790,8 @@ const AnfNodePtr TfBidirectionGruFusion::Process(const FuncGraphPtr &func_graph, MS_CHECK_TRUE_RET(fw_body_graph_pattern != nullptr, nullptr); auto fw_body = utils::cast((*equiv)[fw_vars_[1]]); MS_ASSERT(fw_body != nullptr); - auto fw_body_equiv = TfliteLstmCellFusion::CheckSubGraph(func_graph, fw_body_graph_pattern, fw_primitive_vars_body, - fw_body, kBodyCNodesNum, kBodyNodesNum); + auto fw_body_equiv = TfliteLstmCellFusion::CheckSubGraph(fw_body_graph_pattern, fw_primitive_vars_body, fw_body, + kBodyCNodesNum, kBodyNodesNum); if (fw_body_equiv == nullptr || fw_body_equiv->empty()) { return nullptr; } @@ -802,8 +802,8 @@ const AnfNodePtr TfBidirectionGruFusion::Process(const FuncGraphPtr &func_graph, MS_CHECK_TRUE_RET(bw_body_graph_pattern != nullptr, nullptr); auto bw_body = utils::cast((*equiv)[bw_vars_[1]]); MS_ASSERT(bw_body != nullptr); - auto bw_body_equiv = TfliteLstmCellFusion::CheckSubGraph(func_graph, bw_body_graph_pattern, bw_primitive_vars_body, - bw_body, kBodyCNodesNum, kBodyNodesNum); + auto bw_body_equiv = TfliteLstmCellFusion::CheckSubGraph(bw_body_graph_pattern, bw_primitive_vars_body, bw_body, + kBodyCNodesNum, kBodyNodesNum); if (bw_body_equiv == nullptr || bw_body_equiv->empty()) { return nullptr; } diff --git a/mindspore/lite/tools/optimizer/fusion/tf_lstm_cell_fusion.cc b/mindspore/lite/tools/optimizer/fusion/tf_lstm_cell_fusion.cc index ac9ecf2ab19..9c5478f6d3f 100644 --- a/mindspore/lite/tools/optimizer/fusion/tf_lstm_cell_fusion.cc +++ b/mindspore/lite/tools/optimizer/fusion/tf_lstm_cell_fusion.cc @@ -191,7 +191,7 @@ STATUS TfLstmCellFusion::SetWeightAbstractAndDefault(const ParameterPtr &weight, return RET_ERROR; } const auto param_num = shape[0] * shape[1] * shape[kInputIndexTwo]; - auto tensor_data = new (std::nothrow) float[param_num * sizeof(float)]; + auto tensor_data = new (std::nothrow) float[static_cast(param_num) * sizeof(float)]; std::vector data_diff{0, 3, 2, 1}; if (tensor_data == nullptr) { MS_LOG(DEBUG) << "new data failed"; @@ -204,7 +204,8 @@ STATUS TfLstmCellFusion::SetWeightAbstractAndDefault(const ParameterPtr &weight, } } } - auto tensor_info = lite::CreateTensorInfo(tensor_data, param_num * sizeof(float), shape, kNumberTypeFloat32); + auto tensor_info = + lite::CreateTensorInfo(tensor_data, static_cast(param_num) * sizeof(float), shape, kNumberTypeFloat32); delete[] tensor_data; if (tensor_info == nullptr) { MS_LOG(ERROR) << "create tensor info failed."; @@ -359,11 +360,6 @@ CNodePtr TfLstmCellFusion::CreateLSTMNode(const FuncGraphPtr &func_graph, const MS_CHECK_TRUE_RET(value_node != nullptr, nullptr); auto &vars = while_input_vars_; - - auto limit1 = utils::cast((*equiv)[vars[3]]); - MS_ASSERT(limit1); - auto limit2 = utils::cast((*equiv)[vars[7]]); - MS_ASSERT(limit2); auto weight = utils::cast((*equiv)[vars[9]]); MS_ASSERT(weight); auto bias = utils::cast((*equiv)[vars[10]]); diff --git a/mindspore/lite/tools/optimizer/fusion/tflite_lstm_cell_fusion.cc b/mindspore/lite/tools/optimizer/fusion/tflite_lstm_cell_fusion.cc index 6e918fc4875..9734605364e 100644 --- a/mindspore/lite/tools/optimizer/fusion/tflite_lstm_cell_fusion.cc +++ b/mindspore/lite/tools/optimizer/fusion/tflite_lstm_cell_fusion.cc @@ -329,7 +329,7 @@ bool TfliteLstmCellFusion::CheckReferencedOutputs(const FuncGraphPtr &func_graph auto manager = func_graph->manager(); if (manager == nullptr) { MS_LOG(ERROR) << "manager is nullptr"; - return RET_ERROR; + return false; } auto while_node_users = manager->node_users()[while_cnode]; std::vector valid_indexes{3, 4, 5}; @@ -352,9 +352,9 @@ bool TfliteLstmCellFusion::CheckReferencedOutputs(const FuncGraphPtr &func_graph return true; } -EquivPtr TfliteLstmCellFusion::CheckSubGraph(const FuncGraphPtr &func_graph, const AnfNodePtr &pattern, - const PrimitiveVarMapPtr &primitive_vars, const AnfNodePtr &anf_sub_graph, - const size_t cnode_num, const size_t all_node_num) { +EquivPtr TfliteLstmCellFusion::CheckSubGraph(const AnfNodePtr &pattern, const PrimitiveVarMapPtr &primitive_vars, + const AnfNodePtr &anf_sub_graph, const size_t cnode_num, + const size_t all_node_num) { MS_ASSERT(func_graph != nullptr); MS_ASSERT(pattern != nullptr); MS_ASSERT(primitive_vars != nullptr); @@ -370,9 +370,7 @@ EquivPtr TfliteLstmCellFusion::CheckSubGraph(const FuncGraphPtr &func_graph, con return MatchGraph(sub_graph, primitive_vars, pattern); } -bool TfliteLstmCellFusion::CheckBodyGraph(const FuncGraphPtr &func_graph, const EquivPtr &equiv, - const CNodePtr &while_cnode, float *zoneout_cell, - float *zoneout_hidden) const { +bool TfliteLstmCellFusion::CheckBodyGraph(const EquivPtr &equiv, float *zoneout_cell, float *zoneout_hidden) const { MS_ASSERT(func_graph != nullptr); MS_ASSERT(equiv != nullptr); MS_ASSERT(while_cnode != nullptr); @@ -465,8 +463,9 @@ STATUS TfliteLstmCellFusion::GetConcatedParam(const std::vector &par MS_LOG(ERROR) << "bias data shape error"; return RET_ERROR; } - step = data_shapes[0][0]; - data_size = 8 * step; + step = static_cast(data_shapes[0][0]); + MS_CHECK_INT_MUL_NOT_OVERFLOW(C8NUM, step, RET_ERROR); + data_size = C8NUM * step; new_shape = std::vector({1, data_size}); } else { @@ -475,8 +474,10 @@ STATUS TfliteLstmCellFusion::GetConcatedParam(const std::vector &par return RET_ERROR; } new_shape = std::vector({1, data_shapes[0][0] * kUnidirectionalGateNum, data_shapes[0][1]}); - step = data_shapes[0][0] * data_shapes[0][1]; - data_size = 4 * step; + MS_CHECK_INT_MUL_NOT_OVERFLOW(data_shapes[0][0], data_shapes[0][1], RET_ERROR); + step = static_cast(data_shapes[0][0] * data_shapes[0][1]); + MS_CHECK_INT_MUL_NOT_OVERFLOW(C4NUM, step, RET_ERROR); + data_size = C4NUM * step; } auto tensor_info = lite::CreateTensorInfo(nullptr, 0, new_shape, kNumberTypeFloat32); @@ -528,12 +529,6 @@ CNodePtr TfliteLstmCellFusion::CreateLSTMNode(const FuncGraphPtr &func_graph, co MS_CHECK_TRUE_RET(value_node != nullptr, nullptr); auto &vars = while_input_vars_; - - auto limit1 = utils::cast((*equiv)[vars[3]]); - MS_ASSERT(limit1); - auto limit2 = utils::cast((*equiv)[vars[7]]); - MS_ASSERT(limit2); - auto i2i_weight = utils::cast((*equiv)[vars[9]]); MS_ASSERT(i2i_weight); auto i2f_weight = utils::cast((*equiv)[vars[10]]); @@ -764,8 +759,8 @@ const AnfNodePtr TfliteLstmCellFusion::Process(const FuncGraphPtr &func_graph, c MS_CHECK_TRUE_RET(primitive_vars_cond != nullptr, nullptr); auto cond_graph_pattern = GetCondGraphPattern(primitive_vars_cond); MS_CHECK_TRUE_RET(cond_graph_pattern != nullptr, nullptr); - auto cond_equiv = CheckSubGraph(func_graph, cond_graph_pattern, primitive_vars_cond, while_cnode->input(1), - cond_cnodes_num_, cond_nodes_num_); + auto cond_equiv = + CheckSubGraph(cond_graph_pattern, primitive_vars_cond, while_cnode->input(1), cond_cnodes_num_, cond_nodes_num_); if (cond_equiv == nullptr || cond_equiv->empty()) { return nullptr; } @@ -773,14 +768,14 @@ const AnfNodePtr TfliteLstmCellFusion::Process(const FuncGraphPtr &func_graph, c MS_CHECK_TRUE_RET(primitive_vars_body != nullptr, nullptr); auto body_graph_pattern = GetBodyGraphPattern(primitive_vars_body); MS_CHECK_TRUE_RET(body_graph_pattern != nullptr, nullptr); - auto body_equiv = CheckSubGraph(func_graph, body_graph_pattern, primitive_vars_body, while_cnode->input(2), - body_cnodes_num_, body_nodes_num_); + auto body_equiv = + CheckSubGraph(body_graph_pattern, primitive_vars_body, while_cnode->input(2), body_cnodes_num_, body_nodes_num_); if (body_equiv == nullptr || body_equiv->empty()) { return nullptr; } float zoneout_cell = 0.0f; float zoneout_hidden = 0.0f; - if (!CheckBodyGraph(func_graph, body_equiv, while_cnode, &zoneout_cell, &zoneout_hidden)) { + if (!CheckBodyGraph(body_equiv, &zoneout_cell, &zoneout_hidden)) { return nullptr; } const std::string lstm_name = "lstm_" + while_cnode->fullname_with_scope(); diff --git a/mindspore/lite/tools/optimizer/fusion/tflite_lstm_cell_fusion.h b/mindspore/lite/tools/optimizer/fusion/tflite_lstm_cell_fusion.h index 0daac181552..973b7ba1430 100644 --- a/mindspore/lite/tools/optimizer/fusion/tflite_lstm_cell_fusion.h +++ b/mindspore/lite/tools/optimizer/fusion/tflite_lstm_cell_fusion.h @@ -36,9 +36,8 @@ class TfliteLstmCellFusion : public PatternProcessPass { static EquivPtr MatchGraph(const FuncGraphPtr &func_graph, const PrimitiveVarMapPtr &primitive_vars, const AnfNodePtr &pattern); - static EquivPtr CheckSubGraph(const FuncGraphPtr &func_graph, const AnfNodePtr &pattern, - const PrimitiveVarMapPtr &primitive_vars, const AnfNodePtr &anf_sub_graph, - size_t cnode_num, size_t all_node_num); + static EquivPtr CheckSubGraph(const AnfNodePtr &pattern, const PrimitiveVarMapPtr &primitive_vars, + const AnfNodePtr &anf_sub_graph, size_t cnode_num, size_t all_node_num); static lite::STATUS SetAbstractTuple(const CNodePtr &cnode, int output_num); @@ -68,8 +67,7 @@ class TfliteLstmCellFusion : public PatternProcessPass { private: CNodePtr GetWhileCnode(const AnfNodePtr &cnode) const; - bool CheckBodyGraph(const FuncGraphPtr &func_graph, const EquivPtr &equiv, const CNodePtr &while_cnode, - float *zoneout_cell, float *zoneout_hidden) const; + bool CheckBodyGraph(const EquivPtr &equiv, float *zoneout_cell, float *zoneout_hidden) const; static bool CheckReferencedOutputs(const FuncGraphPtr &func_graph, const CNodePtr &while_cnode); diff --git a/mindspore/lite/tools/optimizer/fusion/transpose_fusion.cc b/mindspore/lite/tools/optimizer/fusion/transpose_fusion.cc index 47427b13f2f..56e485a53a5 100644 --- a/mindspore/lite/tools/optimizer/fusion/transpose_fusion.cc +++ b/mindspore/lite/tools/optimizer/fusion/transpose_fusion.cc @@ -138,9 +138,8 @@ CNodePtr GenTransposeNode(const FuncGraphPtr &func_graph, const AnfNodePtr &inpu return cnode; } -AnfNodePtr TransposeFusion::TransTransFusion(const mindspore::FuncGraphPtr &func_graph, - const mindspore::AnfNodePtr &node) const { - MS_ASSERT(func_graph != nullptr && node != nullptr); +AnfNodePtr TransposeFusion::TransTransFusion(const mindspore::AnfNodePtr &node) const { + MS_ASSERT(node != nullptr); auto trans_cnode_2 = node->cast(); if (IsMarkedTrainOp(trans_cnode_2)) { return nullptr; @@ -181,7 +180,7 @@ AnfNodePtr TransposeFusion::Process(const std::string &pattern_name, const minds return nullptr; } if (pattern_name == "TransTransPatternName") { - return TransTransFusion(func_graph, node); + return TransTransFusion(node); } if (node->cast() == nullptr) { return nullptr; diff --git a/mindspore/lite/tools/optimizer/fusion/transpose_fusion.h b/mindspore/lite/tools/optimizer/fusion/transpose_fusion.h index dbbbec25f75..86b61234909 100644 --- a/mindspore/lite/tools/optimizer/fusion/transpose_fusion.h +++ b/mindspore/lite/tools/optimizer/fusion/transpose_fusion.h @@ -38,7 +38,7 @@ class TransposeFusion : public MultiplePatternProcessPass { VectorRef DefineActivationscalePattern() const; VectorRef DefineTransTransPattern() const; VectorRef DefineBiasAddPattern() const; - AnfNodePtr TransTransFusion(const mindspore::FuncGraphPtr &func_graph, const mindspore::AnfNodePtr &node) const; + AnfNodePtr TransTransFusion(const mindspore::AnfNodePtr &node) const; AnfNodePtr Process(const std::string &pattern_name, const FuncGraphPtr &, const AnfNodePtr &, const EquivPtr &) const override; }; diff --git a/mindspore/lite/tools/optimizer/graph/add_tensor_array.cc b/mindspore/lite/tools/optimizer/graph/add_tensor_array.cc index 47f0c1b8f0b..0296606a610 100644 --- a/mindspore/lite/tools/optimizer/graph/add_tensor_array.cc +++ b/mindspore/lite/tools/optimizer/graph/add_tensor_array.cc @@ -24,10 +24,11 @@ #include "ops/tensor_array_read.h" #include "ops/tensor_array_write.h" #include "tools/converter/ops/ops_def.h" +#include "nnacl/op_base.h" namespace mindspore::opt { constexpr auto kDefaultIndex = 0; -constexpr auto kInputIndex = 1; +constexpr auto kInputNodeIndex = 1; constexpr auto kDefaultNumTensors = 1; constexpr auto kFlowInPlaceHolder = 1; @@ -45,6 +46,8 @@ static bool IsSupportedNode(const BaseRef &n) { } static int SetGraphOutput(const FuncGraphPtr &func_graph, const AnfNodePtr &tensor_array_write_node) { + MS_ASSERT(func_graph != nullptr); + MS_ASSERT(tensor_array_write_node != nullptr); // set tensor_array_write_node as graph output to keep it auto return_node = func_graph->get_return(); if (!CheckPrimitiveType(return_node, prim::kPrimReturn)) { @@ -56,7 +59,7 @@ static int SetGraphOutput(const FuncGraphPtr &func_graph, const AnfNodePtr &tens MS_LOG(ERROR) << "graph return node is not cnode"; return lite::RET_NULL_PTR; } - auto output_node = return_node->input(kInputIndex); + auto output_node = return_node->input(kInputNodeIndex); if (output_node == nullptr) { MS_LOG(ERROR) << "graph output node is null"; return lite::RET_NULL_PTR; @@ -80,8 +83,9 @@ static int SetGraphOutput(const FuncGraphPtr &func_graph, const AnfNodePtr &tens MS_LOG(ERROR) << "make_tuple_prim_ptr is nullptr"; return lite::RET_NULL_PTR; } - auto make_tuple_cnode = - func_graph->NewCNode({NewValueNode(make_tuple_prim_ptr), output_node, tensor_array_write_node}); + auto make_tuple_vnode = NewValueNode(make_tuple_prim_ptr); + MS_CHECK_TRUE_RET(make_tuple_vnode != nullptr, lite::RET_NULL_PTR); + auto make_tuple_cnode = func_graph->NewCNode({make_tuple_vnode, output_node, tensor_array_write_node}); if (make_tuple_cnode == nullptr) { MS_LOG(ERROR) << "NewCNode failed"; return lite::RET_NULL_PTR; @@ -94,7 +98,10 @@ static int SetGraphOutput(const FuncGraphPtr &func_graph, const AnfNodePtr &tens MS_LOG(ERROR) << "return_prim_ptr is nullptr"; return lite::RET_NULL_PTR; } - auto new_return_node = func_graph->NewCNode({NewValueNode(return_prim_ptr), make_tuple_cnode}); + auto return_value_node = NewValueNode(return_prim_ptr); + MS_CHECK_TRUE_RET(return_value_node != nullptr, lite::RET_NULL_PTR); + auto new_return_node = func_graph->NewCNode({return_value_node, make_tuple_cnode}); + MS_CHECK_TRUE_RET(new_return_node != nullptr, lite::RET_NULL_PTR); new_return_node->set_fullname_with_scope(return_cnode->fullname_with_scope()); MS_ASSERT(new_return_node != nullptr); func_graph->set_return(new_return_node); @@ -147,11 +154,7 @@ const AnfNodePtr AddTensorArray::Process(const FuncGraphPtr &func_graph, const A return nullptr; } auto tensor_info = utils::cast(abstract_tensor->GetValueTrack()); - if (tensor_info == nullptr) { - MS_LOG(ERROR) << "tensor::Tensor of abstract is nullptr"; - lite::ReturnCode::GetSingleReturnCode()->UpdateReturnCode(lite::RET_NULL_PTR); - return nullptr; - } + MS_ASSERT(tensor_info != nullptr); if (tensor_info->data_type() == kObjectTypeTensorType) { MS_LOG(ERROR) << "tensor::Tensor of abstract is nullptr"; lite::ReturnCode::GetSingleReturnCode()->UpdateReturnCode(lite::RET_NOT_SUPPORT); @@ -160,35 +163,32 @@ const AnfNodePtr AddTensorArray::Process(const FuncGraphPtr &func_graph, const A // tensor_array auto tensor_array = std::make_shared(); - if (tensor_array == nullptr) { - MS_LOG(ERROR) << "tensor_array is nullptr"; - return nullptr; - } + MS_CHECK_TRUE_RET(tensor_array != nullptr, nullptr); std::vector element_shape; std::for_each(tensor_info->shape().begin(), tensor_info->shape().end(), [&element_shape](int64_t v) { element_shape.push_back(static_cast(v)); }); tensor_array->set_element_shape(element_shape); tensor_array->set_data_type(tensor_info->data_type()); - auto tensor_array_node = func_graph->NewCNode({ - NewValueNode(tensor_array), - NewValueNode(kDefaultNumTensors), - }); + auto tensor_array_vnode = NewValueNode(tensor_array); + MS_CHECK_TRUE_RET(tensor_array_vnode != nullptr, nullptr); + auto num_tensors_vnode = NewValueNode(kDefaultNumTensors); + MS_CHECK_TRUE_RET(num_tensors_vnode != nullptr, nullptr); + auto tensor_array_node = func_graph->NewCNode({tensor_array_vnode, num_tensors_vnode}); MS_ASSERT(tensor_array_node != nullptr); tensor_array_node->set_abstract(abstract->Clone()); tensor_array_node->set_fullname_with_scope(cnode->fullname_with_scope() + "_tensor_array"); // {"handle", "index", "flow_in"} -> {"tensor"} auto tensor_array_read = std::make_shared(); - if (tensor_array_read == nullptr) { - MS_LOG(ERROR) << "tensor_array_read is nullptr"; - return nullptr; - } - auto tensor_array_read_node = func_graph->NewCNode({ - NewValueNode(tensor_array_read), - tensor_array_node, - NewValueNode(kDefaultIndex), - NewValueNode(kFlowInPlaceHolder), - }); + MS_CHECK_TRUE_RET(tensor_array_read != nullptr, nullptr); + auto tensor_array_read_vnode = NewValueNode(tensor_array_read); + MS_CHECK_TRUE_RET(tensor_array_read_vnode != nullptr, nullptr); + auto read_index_vnode = NewValueNode(kDefaultIndex); + MS_CHECK_TRUE_RET(read_index_vnode != nullptr, nullptr); + auto read_flow_in_vnode = NewValueNode(kFlowInPlaceHolder); + MS_CHECK_TRUE_RET(read_flow_in_vnode != nullptr, nullptr); + auto tensor_array_read_node = + func_graph->NewCNode({tensor_array_read_vnode, tensor_array_node, read_index_vnode, read_flow_in_vnode}); MS_ASSERT(tensor_array_read_node != nullptr); tensor_array_read_node->set_abstract(abstract->Clone()); tensor_array_read_node->set_fullname_with_scope(cnode->fullname_with_scope() + "_tensor_array_read"); @@ -196,17 +196,15 @@ const AnfNodePtr AddTensorArray::Process(const FuncGraphPtr &func_graph, const A // {"handle", "index", "value", "flow_in"} -> {"flow_out"} auto tensor_array_write = std::make_shared(); - if (tensor_array_write == nullptr) { - MS_LOG(ERROR) << "tensor_array_write is nullptr"; - return nullptr; - } - auto tensor_array_write_node = func_graph->NewCNode({ - NewValueNode(tensor_array_write), - tensor_array_node, - NewValueNode(kDefaultIndex), - cnode, - NewValueNode(kFlowInPlaceHolder), - }); + MS_CHECK_TRUE_RET(tensor_array_write != nullptr, nullptr); + auto tensor_array_write_vnode = NewValueNode(tensor_array_write); + MS_CHECK_TRUE_RET(tensor_array_write_vnode != nullptr, nullptr); + auto write_index_vnode = NewValueNode(kDefaultIndex); + MS_CHECK_TRUE_RET(write_index_vnode != nullptr, nullptr); + auto write_flow_in_vnode = NewValueNode(kFlowInPlaceHolder); + MS_CHECK_TRUE_RET(write_flow_in_vnode != nullptr, nullptr); + auto tensor_array_write_node = + func_graph->NewCNode({tensor_array_write_vnode, tensor_array_node, write_index_vnode, cnode, write_flow_in_vnode}); if (tensor_array_write_node == nullptr) { MS_LOG(ERROR) << "rensor_array_write_node is nullptr"; return nullptr; diff --git a/mindspore/lite/tools/optimizer/graph/clip_convert_activation_pass.cc b/mindspore/lite/tools/optimizer/graph/clip_convert_activation_pass.cc index 5bbe6872bc7..f00203c3b5f 100644 --- a/mindspore/lite/tools/optimizer/graph/clip_convert_activation_pass.cc +++ b/mindspore/lite/tools/optimizer/graph/clip_convert_activation_pass.cc @@ -35,6 +35,7 @@ bool ClipConvertActivationPass::Run(const FuncGraphPtr &graph) { MS_ASSERT(graph != nullptr); auto node_list = TopoSort(graph->get_return()); for (auto &node : node_list) { + MS_ASSERT(node != nullptr); if (!utils::isa(node)) { continue; } @@ -57,10 +58,12 @@ bool ClipConvertActivationPass::Run(const FuncGraphPtr &graph) { if ((min == -1) && (max == -1)) { if (clip_cnode->size() > kClipMinIndex) { auto min_tensor_info = GetTensorInfo(clip_cnode->input(kClipMinIndex)); + MS_CHECK_TRUE_MSG(min_tensor_info != nullptr, false, "min_tensor_info is nullptr"); if (min_tensor_info->data_type() != mindspore::kNumberTypeFloat32) { MS_LOG(ERROR) << "Clip param type invalid"; return false; } + MS_CHECK_TRUE_MSG(min_tensor_info->data_c() != nullptr, false, "tensor data is nullptr"); min = *reinterpret_cast(min_tensor_info->data_c()); } else { min = FLT_MIN; @@ -68,17 +71,19 @@ bool ClipConvertActivationPass::Run(const FuncGraphPtr &graph) { if (clip_cnode->size() > kClipMaxIndex) { auto max_tensor_info = GetTensorInfo(clip_cnode->input(kClipMaxIndex)); + MS_CHECK_TRUE_MSG(max_tensor_info != nullptr, false, "max_tensor_info is nullptr"); if (max_tensor_info->data_type() != mindspore::kNumberTypeFloat32) { MS_LOG(ERROR) << "Clip param type invalid"; return false; } + MS_CHECK_TRUE_MSG(max_tensor_info->data_c() != nullptr, false, "tensor data is nullptr"); max = *reinterpret_cast(max_tensor_info->data_c()); } else { max = FLT_MAX; } } auto manager = graph->manager(); - + MS_ASSERT(manager != nullptr); auto primitive_c = std::make_shared(); MS_CHECK_TRUE_MSG(primitive_c != nullptr, false, "primitive_c is nullptr"); primitive_c->Init(0, min, max, mindspore::RELU6); diff --git a/mindspore/lite/tools/optimizer/graph/control_flow_pass.cc b/mindspore/lite/tools/optimizer/graph/control_flow_pass.cc index 1972abbd2d9..315f12ef082 100644 --- a/mindspore/lite/tools/optimizer/graph/control_flow_pass.cc +++ b/mindspore/lite/tools/optimizer/graph/control_flow_pass.cc @@ -50,7 +50,6 @@ void ControlFlowPass::VisitedNodesUsedByAfterParts(const std::set &v std::vector *visited_nodes_used_by_after_fg) { std::deque nodes{}; std::set visited_nodes_used_by_after_fg_set{}; - std::set visited_fg_set{}; std::set remain_nodes_set{}; nodes.assign(remain_nodes.begin(), remain_nodes.end()); while (!nodes.empty()) { @@ -150,6 +149,7 @@ int ControlFlowPass::SplitGraph(const FuncGraphPtr &fg, AnfNodePtr *control_flow // notice: fg->nodes() is not work in this pass, cause too many useless parameter have been created. auto node_list = TopoSort(fg->get_return()); for (auto &node : node_list) { + MS_ASSERT(node != nullptr); if (utils::isa(node) && (CheckPrimitiveType(node, prim::kPrimWhile) || CheckPrimitiveType(node, prim::kPrimIf))) { *control_flow_node = node; @@ -194,6 +194,7 @@ int ControlFlowPass::CreateAfterGraph(const FuncGraphPtr &main_fg, const std::ve *after_fg = std::make_shared(); MS_CHECK_TRUE_MSG(*after_fg != nullptr, lite::RET_NULL_PTR, "*after_fg is nullptr"); auto manager = main_fg->manager(); + MS_ASSERT(manager != nullptr); manager->AddFuncGraph(*after_fg); (*after_fg)->set_attr("fmk", MakeValue(static_cast(converter::kFmkTypeTf))); (*after_fg)->set_attr("graph_name", MakeValue(aim_cnode->fullname_with_scope() + "_after_fg")); @@ -244,7 +245,7 @@ int ControlFlowPass::CreateWhileCondCallNode( auto origin_cond_fg_inputs = cond_fg->get_inputs(); for (auto &item : visited_nodes_used_by_after_fg) { bool found = false; - size_t input_index = -1; + size_t input_index = 0; for (size_t i = kPartialFirstInputSize; i < cond_partial_cnode_inputs.size(); ++i) { if (cond_partial_cnode_inputs[i] == item) { found = true; @@ -276,6 +277,7 @@ int ControlFlowPass::CreateWhileCondCallNode( // insert call node std::vector call_node_inputs{cond_partial_cnode}; *cond_call_cnode = fg->NewCNode(call_node_inputs); + MS_CHECK_TRUE_MSG(*cond_call_cnode != nullptr, lite::RET_NULL_PTR, "new cnode is nullptr"); (*cond_call_cnode)->set_fullname_with_scope("call_" + cond_partial_cnode->fullname_with_scope()); return RET_SUCCESS; @@ -284,7 +286,7 @@ int ControlFlowPass::CreateWhileCondCallNode( int ControlFlowPass::CreateWhileBodyPartialNode(const FuncGraphPtr &cond_fg, const CNodePtr &while_cnode, CNodePtr *body_partial_node) { auto body_vnode = while_cnode->input(kWhileBodyIndex); - MS_CHECK_TRUE_MSG(body_vnode != nullptr, lite::RET_NULL_PTR, "body_vnode is nullptr"); + MS_CHECK_TRUE_MSG(body_vnode != nullptr, RET_FAILED, "body_vnode is nullptr"); auto body_fg = GetValueNode>(body_vnode); if (body_fg == nullptr) { MS_LOG(ERROR) << "Get value as func_graph failed."; @@ -302,6 +304,7 @@ int ControlFlowPass::CreateWhileBodyPartialNode(const FuncGraphPtr &cond_fg, con auto cond_fg_inputs = cond_fg->get_inputs(); body_partial_node_inputs.insert(body_partial_node_inputs.end(), cond_fg_inputs.begin(), cond_fg_inputs.end()); *body_partial_node = cond_fg->NewCNode(body_partial_node_inputs); + MS_CHECK_TRUE_MSG(*body_partial_node != nullptr, RET_FAILED, "new cnode is nullptr"); (*body_partial_node)->set_fullname_with_scope("CNode_" + body_fg->get_attr("graph_name")->ToString()); // add after inputs for body fg to call cond fg @@ -312,9 +315,7 @@ int ControlFlowPass::CreateWhileBodyPartialNode(const FuncGraphPtr &cond_fg, con MS_LOG(ERROR) << "fg is not right."; return RET_FAILED; } - auto cond_fg_input_para = cond_fg_inputs[i]->cast(); auto new_parameter = body_fg->add_parameter(); - MS_ASSERT(cond_fg_input_para != nullptr); MS_CHECK_TRUE_MSG(new_parameter != nullptr, lite::RET_NULL_PTR, "new_parameter is nullptr"); new_parameter->set_name(cond_fg_inputs[i]->fullname_with_scope() + "_body_fg_parameter"); new_parameter->set_abstract(cond_fg_inputs[i]->abstract()); @@ -363,7 +364,7 @@ int ControlFlowPass::CreateWhileAfterPartialNode( } auto after_value_node = NewValueNode(after_fg); - MS_CHECK_TRUE_MSG(after_value_node != nullptr, lite::RET_NULL_PTR, "after_value_node is nullptr"); + MS_CHECK_TRUE_MSG(after_value_node != nullptr, RET_FAILED, "after_value_node is nullptr"); ValueNodePtr partial_anf_primitive = lite::GetPartialFusionPrim(); if (partial_anf_primitive == nullptr) { MS_LOG(ERROR) << "GetPartialFusionPrim failed."; @@ -397,7 +398,7 @@ int ControlFlowPass::CreateWhileAfterPartialNode( after_partial_cnode_inputs.push_back(cond_fg_inputs.at(input_index)); auto new_parameter = after_fg->add_parameter(); - MS_CHECK_TRUE_MSG(new_parameter != nullptr, lite::RET_NULL_PTR, "new_parameter != nullptr"); + MS_CHECK_TRUE_MSG(new_parameter != nullptr, RET_FAILED, "new_parameter != nullptr"); new_parameter->set_name(node->fullname_with_scope() + "_after_partial_parameter"); new_parameter->set_abstract(node->abstract()); after_partial_inputs_and_after_fg_inputs_replace_pairs[node] = new_parameter; @@ -407,7 +408,7 @@ int ControlFlowPass::CreateWhileAfterPartialNode( for (auto &input : cond_nodes_used_by_after_partial) { after_partial_cnode_inputs.push_back(visited_nodes_and_cond_fg_inputs_replace_pairs.at(input)); auto new_parameter = after_fg->add_parameter(); - MS_CHECK_TRUE_MSG(new_parameter != nullptr, lite::RET_NULL_PTR, "new_parameter != nullptr"); + MS_CHECK_TRUE_MSG(new_parameter != nullptr, RET_FAILED, "new_parameter != nullptr"); new_parameter->set_name(input->fullname_with_scope() + "_after_fg_parameter"); new_parameter->set_abstract(input->abstract()); visited_nodes_after_fg_replace_pair[visited_nodes_and_cond_fg_inputs_replace_pairs.at(input)] = new_parameter; @@ -417,6 +418,7 @@ int ControlFlowPass::CreateWhileAfterPartialNode( ReplaceNode(after_fg, after_partial_inputs_and_after_fg_inputs_replace_pairs); ReplaceNode(after_fg, visited_nodes_after_fg_replace_pair); *after_partial_cnode = cond_fg->NewCNode(after_partial_cnode_inputs); + MS_CHECK_TRUE_MSG(*after_partial_cnode != nullptr, RET_FAILED, "new cnode is nullptr"); (*after_partial_cnode)->set_fullname_with_scope("CNode_" + after_fg->get_attr("graph_name")->ToString()); return RET_SUCCESS; } @@ -448,7 +450,9 @@ int ControlFlowPass::ProcessWhileOp(const FuncGraphPtr &fg, const std::setinput(kCNodePrimIndex)->cast()->input(kCNodeFirstInputIndex); + auto cond_fg_cnode = cond_call_cnode->input(kCNodePrimIndex)->cast(); + MS_ASSERT(cond_fg_cnode != nullptr); + AnfNodePtr cond_fg_vnode = cond_fg_cnode->input(kCNodeFirstInputIndex); MS_ASSERT(cond_fg_vnode != nullptr); auto cond_fg = GetValueNode>(cond_fg_vnode); MS_CHECK_TRUE_MSG(cond_fg != nullptr, RET_FAILED, "Get value as func_graph failed."); @@ -492,8 +496,9 @@ int ControlFlowPass::ProcessWhileOp(const FuncGraphPtr &fg, const std::setDropNode(while_cnode); fg->set_output(cond_call_cnode); - auto after_fg = - after_partial_cnode->input(kCNodeFirstInputIndex)->cast()->value()->cast(); + auto after_cnode = after_partial_cnode->input(kCNodeFirstInputIndex)->cast(); + MS_ASSERT(after_cnode != nullptr); + auto after_fg = after_cnode->value()->cast(); if (after_fg == nullptr) { MS_LOG(ERROR) << "after_fg is nullptr."; return RET_FAILED; @@ -506,7 +511,9 @@ int ControlFlowPass::ProcessWhileOp(const FuncGraphPtr &fg, const std::set *then_partial_cnode_inputs) { auto if_inputs = if_cnode->inputs(); - auto partial_fg_name = partial_fg->get_attr("graph_name")->ToString(); + auto fg_name_attr = partial_fg->get_attr("graph_name"); + MS_CHECK_TRUE_RET(fg_name_attr != nullptr, RET_FAILED); + auto partial_fg_name = fg_name_attr->ToString(); std::vector if_external_inputs{}; if_external_inputs.assign(if_inputs.begin() + kIfMinInputSize, if_inputs.end()); auto origin_then_fg_inputs = partial_fg->get_inputs(); @@ -523,7 +530,13 @@ int ControlFlowPass::CreateIfPartialNodeExternalInputs(const CNodePtr &if_cnode, auto pos = partial_fg_name.size() + sizeof("_input_"); auto pos2 = fg_input_name.find('_', pos); auto idx_str = fg_input_name.substr(pos - 1, pos2 - pos + 1); - auto partial_idx = std::stoi(idx_str); + auto partial_idx = 0; + try { + partial_idx = std::stoi(idx_str); + } catch (const std::exception &e) { + MS_LOG(ERROR) << "Get index failed: " << e.what(); + return RET_FAILED; + } then_partial_cnode_inputs->push_back(if_external_inputs.at(partial_idx)); } } @@ -552,7 +565,7 @@ int ControlFlowPass::CreateIfPartialNode(const FuncGraphPtr &fg, const size_t &i auto origin_then_fg_inputs = then_fg->get_inputs(); for (auto &item : *visited_nodes_used_by_after_fg) { bool found = false; - size_t input_index = -1; + size_t input_index = 0; for (size_t i = kPartialFirstInputSize; i < then_partial_cnode_inputs.size(); ++i) { if (then_partial_cnode_inputs[i] == item) { found = true; @@ -580,7 +593,10 @@ int ControlFlowPass::CreateIfPartialNode(const FuncGraphPtr &fg, const size_t &i then_nodes_used_by_after_partial.push_back(new_parameter); } *then_partial_cnode = fg->NewCNode(then_partial_cnode_inputs); - auto then_fg_name = then_fg->get_attr("graph_name")->ToString(); + MS_CHECK_TRUE_MSG(*then_partial_cnode != nullptr, RET_FAILED, "new cnode is nullptr"); + auto fg_name_attr = then_fg->get_attr("graph_name"); + MS_CHECK_TRUE_RET(fg_name_attr != nullptr, RET_FAILED); + auto then_fg_name = fg_name_attr->ToString(); (*then_partial_cnode)->set_fullname_with_scope("partial_" + then_fg_name); // create after partial node @@ -764,6 +780,7 @@ int ControlFlowPass::ProcessControlOp(const FuncGraphPtr &fg) { } bool ControlFlowPass::Run(const FuncGraphPtr &fg) { + MS_ASSERT(fg != nullptr); to_process_q.push_back(fg); while (!to_process_q.empty()) { auto cur_fg = to_process_q.front(); diff --git a/mindspore/lite/tools/optimizer/graph/conv1d_weight_expanding_pass.cc b/mindspore/lite/tools/optimizer/graph/conv1d_weight_expanding_pass.cc index d008af4f334..a1bb88eaa49 100644 --- a/mindspore/lite/tools/optimizer/graph/conv1d_weight_expanding_pass.cc +++ b/mindspore/lite/tools/optimizer/graph/conv1d_weight_expanding_pass.cc @@ -79,7 +79,7 @@ bool Conv1DWeightExpandingPass::Run(const FuncGraphPtr &func_graph) { MS_ASSERT(weight_node != nullptr); auto prim = GetValueNode(conv_cnode->input(0)); - MS_CHECK_TRUE_MSG(prim != nullptr, RET_FAILED, "GetValueNode failed"); + MS_CHECK_TRUE_MSG(prim != nullptr, false, "GetValueNode failed"); schema::Format schema_format = schema::Format::Format_KCHW; if (prim->GetAttr(ops::kFormat) != nullptr) { schema_format = static_cast(GetValue(prim->GetAttr(ops::kFormat))); @@ -91,6 +91,6 @@ bool Conv1DWeightExpandingPass::Run(const FuncGraphPtr &func_graph) { return false; } } - return RET_OK; + return true; } } // namespace mindspore::opt diff --git a/mindspore/lite/tools/optimizer/graph/decrease_transpose_algo.cc b/mindspore/lite/tools/optimizer/graph/decrease_transpose_algo.cc index e5d4c7aa46c..f5210c184ea 100644 --- a/mindspore/lite/tools/optimizer/graph/decrease_transpose_algo.cc +++ b/mindspore/lite/tools/optimizer/graph/decrease_transpose_algo.cc @@ -233,8 +233,8 @@ STATUS DecreaseTransposeAlgo::PostTransposeFusion(const FuncGraphPtr &func_graph return lite::RET_OK; } -STATUS DecreaseTransposeAlgo::GenNewInput(const FuncGraphPtr &func_graph, const CNodePtr &cnode, std::vector perm, - bool before, size_t index) { +STATUS DecreaseTransposeAlgo::GenNewInput(const FuncGraphPtr &func_graph, const CNodePtr &cnode, + const std::vector perm, bool before, size_t index) { MS_ASSERT(func_graph != nullptr && cnode != nullptr); AnfNodePtr new_input = nullptr; new_input = transpose_strategy_.TransposePairFuseWhenInsert(func_graph, cnode, perm, before, index); @@ -388,6 +388,7 @@ STATUS DecreaseTransposeAlgo::InsertPostTransNode(const FuncGraphPtr &func_graph return lite::RET_ERROR; } else { tuple_get_item = GenTupleGetItemNode(func_graph, cnode, 0); + MS_CHECK_TRUE_RET(tuple_get_item != nullptr, lite::RET_ERROR); post_node = tuple_get_item; func_graph->manager()->Replace(cnode, tuple_get_item); } @@ -489,7 +490,13 @@ int DecreaseTransposeAlgo::SetSubGraphInput(const CNodePtr &cnode, const FuncGra auto last_underline = node_name.find_last_of("_"); node_name = node_name.substr(0, last_underline); last_underline = node_name.find_last_of("_"); - auto index = std::stoi(node_name.substr(last_underline + 1)) + static_cast(kInputSizeThree); + auto index = 0; + try { + index = std::stoi(node_name.substr(last_underline + 1)) + static_cast(kInputSizeThree); + } catch (const std::exception &e) { + MS_LOG(ERROR) << "Get index failed: " << e.what(); + return lite::RET_ERROR; + } param_node->set_abstract(GetCNodeInputAbstract(cnode, index)->Clone()); if (utils::isa(cnode->input(index))) { ShapeVector shape_vec = {-1}; diff --git a/mindspore/lite/tools/optimizer/graph/decrease_transpose_algo.h b/mindspore/lite/tools/optimizer/graph/decrease_transpose_algo.h index dd252476685..44f144ff6c2 100644 --- a/mindspore/lite/tools/optimizer/graph/decrease_transpose_algo.h +++ b/mindspore/lite/tools/optimizer/graph/decrease_transpose_algo.h @@ -41,7 +41,7 @@ class DecreaseTransposeAlgo : public Pass { private: STATUS InsertPostTransNode(const FuncGraphPtr &func_graph, const CNodePtr &cnode, const std::vector &perm); - STATUS GenNewInput(const FuncGraphPtr &func_graph, const CNodePtr &cnode, std::vector perm, bool before, + STATUS GenNewInput(const FuncGraphPtr &func_graph, const CNodePtr &cnode, const std::vector perm, bool before, size_t index = 0); bool DecreaseTransposeForSingleOp(const FuncGraphPtr &func_graph); bool DecreaseTransposeForMultiOp(const FuncGraphPtr &func_graph); diff --git a/mindspore/lite/tools/optimizer/graph/group_depthwise_op_convert_pass.cc b/mindspore/lite/tools/optimizer/graph/group_depthwise_op_convert_pass.cc index 0f784103abb..daabec5089c 100644 --- a/mindspore/lite/tools/optimizer/graph/group_depthwise_op_convert_pass.cc +++ b/mindspore/lite/tools/optimizer/graph/group_depthwise_op_convert_pass.cc @@ -62,7 +62,9 @@ bool GroupDepthwiseOpConvertPass::Run(const FuncGraphPtr &graph) { MS_LOG(ERROR) << "the node input is invalid."; return false; } - auto data_shape = utils::cast(data_node->GetShapeTrack())->shape(); + auto data_shape_ptr = utils::cast(data_node->GetShapeTrack()); + MS_ASSERT(data_shape_ptr != nullptr); + auto data_shape = data_shape_ptr->shape(); if (data_shape.empty()) { MS_LOG(DEBUG) << "the tensor's shape is dynamic."; return true; @@ -72,11 +74,15 @@ bool GroupDepthwiseOpConvertPass::Run(const FuncGraphPtr &graph) { MS_LOG(ERROR) << "the weight node input is invalid."; return false; } - auto weight_shape = utils::cast(weight_data_node->GetShapeTrack())->shape(); + auto weight_shape_ptr = utils::cast(weight_data_node->GetShapeTrack()); + MS_ASSERT(weight_shape_ptr != nullptr); + auto weight_shape = weight_shape_ptr->shape(); if (weight_shape.empty()) { MS_LOG(DEBUG) << "the weight's shape is dynamic."; return true; } + MS_CHECK_TRUE_RET(data_shape.size() == DIMENSION_4D, false); + MS_CHECK_TRUE_RET(weight_shape.size() == DIMENSION_4D, false); if (data_shape[3] == 1 || data_shape[3] != weight_shape[3]) { conv2d_fusion->EraseAttr(ops::kIsDepthWise); conv2d_fusion->set_group(static_cast(data_shape[3])); diff --git a/mindspore/lite/tools/optimizer/graph/infershape_pass.cc b/mindspore/lite/tools/optimizer/graph/infershape_pass.cc index 370fe113ad2..1383cbb4411 100644 --- a/mindspore/lite/tools/optimizer/graph/infershape_pass.cc +++ b/mindspore/lite/tools/optimizer/graph/infershape_pass.cc @@ -50,7 +50,9 @@ int GetCNodeCertainInputFormat(const CNodePtr cnode, int index, mindspore::Forma MS_LOG(ERROR) << "cnode has no format attr. " << real_cnode->fullname_with_scope(); return lite::RET_ERROR; } - *format = static_cast(GetValue(primitive->GetAttr(ops::kFormat))); + auto format_attr = primitive->GetAttr(ops::kFormat); + MS_CHECK_TRUE_MSG(format_attr != nullptr, lite::RET_NULL_PTR, "GetAttr Failed"); + *format = static_cast(GetValue(format_attr)); if (CheckPrimitiveType(real_cnode, prim::kPrimTranspose)) { std::vector perm; if (GetTransposePerm(real_cnode, &perm) != lite::RET_OK) { @@ -184,7 +186,7 @@ STATUS InferShapePass::InferProcess(const FuncGraphPtr &func_graph) { return lite::RET_ERROR; } auto ret = SetSubGraphInput(cnode, sub_func_graph); - if (ret != RET_OK) { + if (ret != lite::RET_OK) { MS_LOG(ERROR) << "SetSubGraphInput failed: " << ret; return lite::RET_ERROR; } @@ -202,7 +204,7 @@ STATUS InferShapePass::InferProcess(const FuncGraphPtr &func_graph) { return lite::RET_ERROR; } ret = SetSubGraphInput(cnode, sub_func_graph); - if (ret != RET_OK) { + if (ret != lite::RET_OK) { MS_LOG(ERROR) << "SetSubGraphInput failed: " << ret; return lite::RET_ERROR; } @@ -215,7 +217,7 @@ STATUS InferShapePass::InferProcess(const FuncGraphPtr &func_graph) { return lite::RET_ERROR; } ret = SetSubGraphAbstract(cnode, sub_func_graph); - if (ret != RET_OK) { + if (ret != lite::RET_OK) { MS_LOG(ERROR) << "SetSubGraphAbstract failed: " << ret; return lite::RET_ERROR; } @@ -241,13 +243,20 @@ STATUS InferShapePass::SetSubGraphInput(const CNodePtr &cnode, const FuncGraphPt auto last_underline = node_name.find_last_of("_"); node_name = node_name.substr(0, last_underline); last_underline = node_name.find_last_of("_"); - auto index = std::stoi(node_name.substr(last_underline + 1)) + 3; + auto index = 0; + try { + index = std::stoi(node_name.substr(last_underline + 1)) + 3; + } catch (const std::exception &e) { + MS_LOG(ERROR) << "Get index failed: " << e.what(); + return RET_ERROR; + } param_node->set_abstract(opt::GetCNodeInputAbstract(cnode, index)->Clone()); if (utils::isa(cnode->input(index))) { ShapeVector shape_vec = {-1}; auto out_cnode = cnode->input(index)->cast(); MS_ASSERT(trans_cnode != nullptr); auto out_prim = GetValueNode(out_cnode->input(0)); + MS_CHECK_TRUE_MSG(out_prim != nullptr, lite::RET_ERROR, "GetValueNode Failed"); if (out_prim->GetAttr(opt::kInferDone) == nullptr || !GetValue(out_prim->GetAttr(opt::kInferDone))) { auto abstract_shape = std::make_shared(shape_vec); CHECK_NULL_RETURN(abstract_shape); diff --git a/mindspore/lite/tools/optimizer/graph/node_infershape.cc b/mindspore/lite/tools/optimizer/graph/node_infershape.cc index b3c0e0a08cc..1ee56e9ccaa 100644 --- a/mindspore/lite/tools/optimizer/graph/node_infershape.cc +++ b/mindspore/lite/tools/optimizer/graph/node_infershape.cc @@ -34,7 +34,7 @@ namespace opt { namespace { constexpr int kInputChannal = 3; constexpr size_t INITIAL_SIZE = 1024; -void RectifyFormat(const CNodePtr &cnode, const std::vector &inputs, FmkType fmk_type) { +void RectifyFormat(const std::vector &inputs, FmkType fmk_type) { MS_ASSERT(cnode != nullptr); if (fmk_type != converter::kFmkTypeOnnx) { return; @@ -127,7 +127,7 @@ STATUS NodeInferShape::InferShape(const CNodePtr &cnode) { fbb.Clear(); return lite::RET_ERROR; } - RectifyFormat(cnode, inputs, fmk_type_); + RectifyFormat(inputs, fmk_type_); ret = KernelInferShape(inputs, outputs, parameter); if (parameter->destroy_func_ != nullptr) { parameter->destroy_func_(parameter); @@ -208,7 +208,8 @@ std::vector NodeInferShape::GetIntVecInput(const CNodePtr &cnode, size_t in if (specify_tensors.front()->shape().size() != 1) { return {}; } - tensor_data.resize(specify_tensors.front()->shape()[0]); + MS_CHECK_GE(specify_tensors.front()->shape()[0], 0, {}); + tensor_data.resize(static_cast(specify_tensors.front()->shape()[0])); if (memcpy_s(tensor_data.data(), tensor_data.size() * sizeof(int), specify_tensors.front()->data(), specify_tensors.front()->Size()) != EOK) { return {}; diff --git a/mindspore/lite/tools/optimizer/graph/redundant_op_remove_pass.cc b/mindspore/lite/tools/optimizer/graph/redundant_op_remove_pass.cc index 0f0ddc9fd79..72cef9664f9 100644 --- a/mindspore/lite/tools/optimizer/graph/redundant_op_remove_pass.cc +++ b/mindspore/lite/tools/optimizer/graph/redundant_op_remove_pass.cc @@ -264,6 +264,27 @@ int RemoveRedundantOpPass::RemoveDropoutOp(const AnfNodePtr &anf_node, const Fun return lite::RET_OK; } +int RemoveRedundantOpPass::GetConstDataFromInputNode(const CNodePtr &cnode, lite::DataInfo *data_info) { + MS_ASSERT(cnode != nullptr); + MS_ASSERT(data_info != nullptr); + auto padding_node = cnode->input(kInputIndexTwo); + MS_ASSERT(padding_node != nullptr); + if (utils::isa(padding_node)) { + auto status = lite::FetchDataFromParameterNode(cnode, 2, converter::kFmkTypeMs, false, data_info); + if (status != lite::RET_OK && status != lite::RET_NO_CHANGE) { + MS_LOG(ERROR) << "fetch data from parameter node failed."; + return lite::RET_ERROR; + } + } else if (utils::isa(padding_node)) { + auto status = lite::FetchDataFromValueNode(cnode, 2, converter::kFmkTypeMs, false, data_info); + if (status != lite::RET_OK && status != lite::RET_NO_CHANGE) { + MS_LOG(ERROR) << "fetch data from value node failed."; + return lite::RET_ERROR; + } + } + return lite::RET_OK; +} + int RemoveRedundantOpPass::RemoveInvalidPadOp(const AnfNodePtr &anf_node, const FuncGraphManagerPtr &manager) { if (!utils::isa(anf_node)) { MS_LOG(DEBUG) << "anf node is node a cnode."; @@ -278,20 +299,10 @@ int RemoveRedundantOpPass::RemoveInvalidPadOp(const AnfNodePtr &anf_node, const } auto is_invalid = true; if (cnode->size() > kInputSizeTwo) { - auto padding_node = cnode->input(kInputIndexTwo); lite::DataInfo data_info; - if (utils::isa(padding_node)) { - auto status = lite::FetchDataFromParameterNode(cnode, 2, converter::kFmkTypeMs, false, &data_info); - if (status != lite::RET_OK && status != lite::RET_NO_CHANGE) { - MS_LOG(ERROR) << "fetch data from parameter node failed."; - return lite::RET_ERROR; - } - } else if (utils::isa(padding_node)) { - auto status = lite::FetchDataFromValueNode(cnode, 2, converter::kFmkTypeMs, false, &data_info); - if (status != lite::RET_OK && status != lite::RET_NO_CHANGE) { - MS_LOG(ERROR) << "fetch data from value node failed."; - return lite::RET_ERROR; - } + if (GetConstDataFromInputNode(cnode, &data_info) != RET_OK) { + MS_LOG(ERROR) << "Get pad data failed."; + return lite::RET_ERROR; } if (!data_info.data_.empty()) { auto pad_data = reinterpret_cast(data_info.data_.data()); @@ -308,19 +319,18 @@ int RemoveRedundantOpPass::RemoveInvalidPadOp(const AnfNodePtr &anf_node, const } else { auto pad_prim = utils::cast>(primitive); MS_ASSERT(pad_prim != nullptr); - if (pad_prim->GetAttr(ops::kPadding) != nullptr) { - auto pad_data = pad_prim->get_paddings(); - for (size_t i = 0; i < pad_data.size(); i++) { - for (size_t j = 0; j < pad_data[i].size(); j++) { - if (pad_data[i][j] != 0) { - is_invalid = false; - break; - } - } - if (is_invalid == false) { + MS_CHECK_TRUE_RET(pad_prim->GetAttr(ops::kPadding) != nullptr, lite::RET_ERROR); + auto pad_data = pad_prim->get_paddings(); + for (size_t i = 0; i < pad_data.size(); i++) { + for (size_t j = 0; j < pad_data[i].size(); j++) { + if (pad_data[i][j] != 0) { + is_invalid = false; break; } } + if (is_invalid == false) { + break; + } } } if (is_invalid) { diff --git a/mindspore/lite/tools/optimizer/graph/redundant_op_remove_pass.h b/mindspore/lite/tools/optimizer/graph/redundant_op_remove_pass.h index 40428833dd3..9e71026176a 100644 --- a/mindspore/lite/tools/optimizer/graph/redundant_op_remove_pass.h +++ b/mindspore/lite/tools/optimizer/graph/redundant_op_remove_pass.h @@ -21,6 +21,7 @@ #include "backend/optimizer/common/pass.h" #include "tools/converter/converter_flags.h" #include "tools/optimizer/common/gllo_utils.h" +#include "tools/anf_exporter/fetch_content.h" using mindspore::converter::FmkType; namespace mindspore::opt { @@ -38,6 +39,7 @@ class RemoveRedundantOpPass : public Pass { bool Run(const FuncGraphPtr &graph) override; private: + int GetConstDataFromInputNode(const CNodePtr &cnode, lite::DataInfo *data_info); bool is_train_model_ = false; std::set remove_cnode_; }; diff --git a/mindspore/lite/tools/optimizer/graph/slice_prepose_pass.cc b/mindspore/lite/tools/optimizer/graph/slice_prepose_pass.cc index 9b211d2fdd0..0dd3d4d3185 100644 --- a/mindspore/lite/tools/optimizer/graph/slice_prepose_pass.cc +++ b/mindspore/lite/tools/optimizer/graph/slice_prepose_pass.cc @@ -222,7 +222,7 @@ STATUS SlicePreposePass::SwapSliceWithPreceed(const FuncGraphPtr &graph, const C return RET_OK; } -ValueNodePtr SlicePreposePass::CreateSliceValueNode(const FuncGraphPtr &graph, const std::vector &axes) { +ValueNodePtr SlicePreposePass::CreateSliceValueNode(const std::vector &axes) { MS_ASSERT(graph != nullptr); MS_ASSERT(slice_cnode != nullptr); auto new_slice = std::make_shared(); @@ -233,7 +233,7 @@ ValueNodePtr SlicePreposePass::CreateSliceValueNode(const FuncGraphPtr &graph, c return value_node; } -ValueNodePtr SlicePreposePass::CopySliceValueNode(const FuncGraphPtr &graph, const CNodePtr &slice_cnode) { +ValueNodePtr SlicePreposePass::CopySliceValueNode(const CNodePtr &slice_cnode) { MS_ASSERT(graph != nullptr); MS_ASSERT(slice_cnode != nullptr); auto slice_c = GetValueNode>(slice_cnode->input(0)); @@ -400,7 +400,7 @@ CNodePtr SlicePreposePass::CreateReshapeCNode(const FuncGraphPtr &graph, const s return reshape_cnode; } -bool SlicePreposePass::SiblingsAreSameSlice(const FuncGraphPtr &graph, const NodeUsedListPtr &output_node_list, +bool SlicePreposePass::SiblingsAreSameSlice(const NodeUsedListPtr &output_node_list, const std::vector &ref_shape) { MS_ASSERT(graph != nullptr); MS_ASSERT(output_node_list != nullptr); @@ -512,15 +512,15 @@ int64_t SlicePreposePass::GetReshapeAbnormalIndexOut(const CNodePtr &slice_cnode MS_ASSERT(shape_out_copy != nullptr); MS_ASSERT(is_normal_mode != nullptr); MS_ASSERT(support_abnormal_mode != nullptr); + int64_t abnormal_index_out = -1; auto slice_node = GetSlice(slice_cnode); if (slice_node == nullptr) { MS_LOG(ERROR) << "slice is nullptr"; - return false; + return abnormal_index_out; } auto slice_axes = slice_node->get_axes(); auto slice_begin = GetSliceBeginAndSize(slice_cnode, SliceBeginIndex); auto slice_size = GetSliceBeginAndSize(slice_cnode, SliceSizeIndex); - int64_t abnormal_index_out = -1; for (size_t j = 0; j < shape_out.size(); ++j) { int index = -1; for (size_t i = 0; i < slice_axes.size(); ++i) { @@ -532,8 +532,8 @@ int64_t SlicePreposePass::GetReshapeAbnormalIndexOut(const CNodePtr &slice_cnode if (index == -1) { continue; } - MS_CHECK_TRUE_MSG(static_cast(slice_begin.size()) > index, false, "slice_begin.size() is wrong"); - MS_CHECK_TRUE_MSG(static_cast(slice_size.size()) > index, false, "slice_size.size() is wrong"); + MS_CHECK_TRUE_MSG(static_cast(slice_begin.size()) > index, abnormal_index_out, "slice_begin.size() is wrong"); + MS_CHECK_TRUE_MSG(static_cast(slice_size.size()) > index, abnormal_index_out, "slice_size.size() is wrong"); if (slice_begin[index] != 0 || (slice_size[index] != -1 && slice_size[index] != shape_out[j])) { if (mapped_axe[j] == -1) { if (is_normal_mode) { @@ -634,7 +634,7 @@ CNodePtr SlicePreposePass::CreateSlice1ForReshapePrepose(const FuncGraphPtr &gra } else { new_size1[abnormal_axe_in] = static_cast(shape_in[abnormal_axe_in] - count_sliced_axe_in); } - auto new_slice1 = CreateSliceValueNode(graph, new_axes1); + auto new_slice1 = CreateSliceValueNode(new_axes1); if (new_slice1 == nullptr) { MS_LOG(ERROR) << "CreateSliceValueNode failed"; return nullptr; @@ -660,8 +660,7 @@ CNodePtr SlicePreposePass::CreateSlice1ForReshapePrepose(const FuncGraphPtr &gra CNodePtr SlicePreposePass::CreateSlice2ForReshapePrepose(const FuncGraphPtr &graph, const CNodePtr &slice_cnode, const CNodePtr &new_reshape1_cnode, const std::vector &new_shape1, - const int64_t abnormal_axe_in, - const int64_t count_sliced_axe_in, const int64_t count_sliced2, + const int64_t abnormal_axe_in, const int64_t count_sliced2, const bool slice_at_front) { MS_ASSERT(graph != nullptr); MS_ASSERT(slice_cnode != nullptr); @@ -679,7 +678,7 @@ CNodePtr SlicePreposePass::CreateSlice2ForReshapePrepose(const FuncGraphPtr &gra } else { new_size2[abnormal_axe_in] = static_cast(count_sliced2); } - auto new_slice2 = CreateSliceValueNode(graph, new_axes2); + auto new_slice2 = CreateSliceValueNode(new_axes2); if (new_slice2 == nullptr) { MS_LOG(ERROR) << "CreateSliceValueNode failed"; return nullptr; @@ -782,9 +781,8 @@ bool SlicePreposePass::PreposeWithAbnormalReshape(const FuncGraphPtr &graph, con const int64_t count_sliced_abnormal_axe = shape_out[abnormal_axe_out] - (count_sliced_axe_front + count_sliced_axe_rear); const int64_t count_sliced2 = count_sliced_abnormal_axe * outer_size_out; - auto new_slice2_cnode = - CreateSlice2ForReshapePrepose(graph, slice_cnode, new_reshape1_cnode, new_shape1, abnormal_axe_in, - count_sliced_axe_in, count_sliced2, slice_at_front); + auto new_slice2_cnode = CreateSlice2ForReshapePrepose(graph, slice_cnode, new_reshape1_cnode, new_shape1, + abnormal_axe_in, count_sliced2, slice_at_front); if (new_slice2_cnode == nullptr) { return false; } @@ -977,7 +975,7 @@ bool SlicePreposePass::PreposeWithMatmul(const FuncGraphPtr &graph, const CNodeP return false; } auto slice_node = GetSlice(slice_cnode); - MS_CHECK_TRUE_MSG(slice_node != nullptr, RET_ERROR, "slice is nullptr"); + MS_CHECK_TRUE_MSG(slice_node != nullptr, false, "slice is nullptr"); auto axes = slice_node->get_axes(); auto begin = GetSliceBeginAndSize(slice_cnode, SliceBeginIndex); auto size = GetSliceBeginAndSize(slice_cnode, SliceSizeIndex); @@ -1012,7 +1010,7 @@ bool SlicePreposePass::PreposeWithMatmul(const FuncGraphPtr &graph, const CNodeP left_size[i] = -1; } } - auto left_slice_vnode = CreateSliceValueNode(graph, left_axes); + auto left_slice_vnode = CreateSliceValueNode(left_axes); MS_CHECK_TRUE_MSG(left_slice_vnode != nullptr, false, "CreateSliceValueNode failed"); auto begin_parameter = BuildIntVecParameterNode( graph, left_begin, slice_cnode->fullname_with_scope() + "_begin_" + std::to_string(node_name_index)); @@ -1050,7 +1048,7 @@ bool SlicePreposePass::PreposeWithMatmul(const FuncGraphPtr &graph, const CNodeP MS_CHECK_TRUE_MSG(begin_parameter != nullptr, false, "BuildIntVecParameterNode Failed"); MS_CHECK_TRUE_MSG(size_parameter != nullptr, false, "BuildIntVecParameterNode Failed"); node_name_index += 1; - auto right_slice_vnode = CreateSliceValueNode(graph, right_axes); + auto right_slice_vnode = CreateSliceValueNode(right_axes); MS_CHECK_TRUE_MSG(right_slice_vnode != nullptr, false, "CreateSliceValueNode failed"); const std::vector inputs = {right_slice_vnode, matmul_cnode->input(2), begin_parameter, size_parameter}; auto new_slice_cnode = InsertSlice(graph, inputs, matmul_cnode, 2, tr); @@ -1094,7 +1092,7 @@ bool SlicePreposePass::PreposeWithFullConnection(const FuncGraphPtr &graph, cons auto slice_node = GetSlice(slice_cnode); if (slice_node == nullptr) { MS_LOG(ERROR) << "slice is nullptr"; - return RET_ERROR; + return false; } auto axes = slice_node->get_axes(); auto begin = GetSliceBeginAndSize(slice_cnode, SliceBeginIndex); @@ -1134,7 +1132,7 @@ bool SlicePreposePass::PreposeWithFullConnection(const FuncGraphPtr &graph, cons std::vector new_size(shape_in.size(), -1); new_begin[mapped_axe[0]] = begin[0]; new_size[mapped_axe[0]] = size[0]; - auto new_slice_vnode = CreateSliceValueNode(graph, new_axes); + auto new_slice_vnode = CreateSliceValueNode(new_axes); if (new_slice_vnode == nullptr) { MS_LOG(ERROR) << "CreateSliceValueNode failed"; return false; @@ -1267,7 +1265,7 @@ bool SlicePreposePass::PreposeWithArithmetic(const FuncGraphPtr &graph, const CN continue; } else if (shape.empty()) { // infershape failed at this input if (IsScalarNode(another_input)) { // if another input is scalar, we can process this one - auto new_slice_vnode = CopySliceValueNode(graph, slice_cnode); + auto new_slice_vnode = CopySliceValueNode(slice_cnode); if (new_slice_vnode == nullptr) { changed = false; break; @@ -1299,7 +1297,7 @@ bool SlicePreposePass::PreposeWithArithmetic(const FuncGraphPtr &graph, const CN changed = false; break; } - auto new_slice_vnode = CreateSliceValueNode(graph, new_axes); + auto new_slice_vnode = CreateSliceValueNode(new_axes); if (new_slice_vnode == nullptr) { changed = false; break; @@ -1525,7 +1523,7 @@ bool SlicePreposePass::Run(const FuncGraphPtr &graph) { } auto output_node_list = GetRealNodeUsedList(graph, utils::cast(preceed_node)); if (output_node_list->size() > 1) { // referenced by multi nodes - if (SiblingsAreSameSlice(graph, output_node_list) && MergeParallelSlice(graph, output_node_list)) { + if (SiblingsAreSameSlice(output_node_list) && MergeParallelSlice(graph, output_node_list)) { this_time_changed = true; break; } diff --git a/mindspore/lite/tools/optimizer/graph/slice_prepose_pass.h b/mindspore/lite/tools/optimizer/graph/slice_prepose_pass.h index 67fd914ec7e..6d32dcb3655 100644 --- a/mindspore/lite/tools/optimizer/graph/slice_prepose_pass.h +++ b/mindspore/lite/tools/optimizer/graph/slice_prepose_pass.h @@ -43,8 +43,8 @@ class SlicePreposePass : public Pass { static void ClearCNodeAbstractValue(const CNodePtr &cnode); static STATUS SwapSliceWithPreceed(const FuncGraphPtr &graph, const CNodePtr &slice_cnode, const CNodePtr &preceed_cnode, int index, const TransactionPtr &tr = nullptr); - static ValueNodePtr CreateSliceValueNode(const FuncGraphPtr &graph, const std::vector &axes); - static ValueNodePtr CopySliceValueNode(const FuncGraphPtr &graph, const CNodePtr &slice_cnode); + static ValueNodePtr CreateSliceValueNode(const std::vector &axes); + static ValueNodePtr CopySliceValueNode(const CNodePtr &slice_cnode); static CNodePtr InsertSlice(const FuncGraphPtr &graph, const std::vector &inputs, const CNodePtr &preceed_cnode, int index, const TransactionPtr &tr); static STATUS VerifySliceAttrs(const CNodePtr &slice_cnode, int dim = -1); @@ -52,8 +52,7 @@ class SlicePreposePass : public Pass { std::vector *axes, std::vector *begin, std::vector *size); static CNodePtr CreateReshapeCNode(const FuncGraphPtr &graph, const std::vector &shape, const AbstractBasePtr &abstract, const CNodePtr &preceed_cnode); - static bool SiblingsAreSameSlice(const FuncGraphPtr &graph, const NodeUsedListPtr &output_node_list, - const std::vector &ref_shape = {}); + static bool SiblingsAreSameSlice(const NodeUsedListPtr &output_node_list, const std::vector &ref_shape = {}); static int64_t GetReshapeAbnormalAxeIn(const std::vector &shape_in, const std::vector &shape_out, std::vector *mapped_axe); static int64_t GetReshapeAbnormalIndexOut(const CNodePtr &slice_cnode, const std::vector &mapped_axe, @@ -70,8 +69,7 @@ class SlicePreposePass : public Pass { static CNodePtr CreateSlice2ForReshapePrepose(const FuncGraphPtr &graph, const CNodePtr &slice_cnode, const CNodePtr &new_reshape1_cnode, const std::vector &new_shape1, int64_t abnormal_axe_in, - int64_t count_sliced_axe_in, int64_t count_sliced2, - bool slice_at_front); + int64_t count_sliced2, bool slice_at_front); static bool PreposeWithAbnormalReshape(const FuncGraphPtr &graph, const CNodePtr &slice_cnode, const CNodePtr &reshape_cnode, const CNodePtr &matmul_cnode, const std::vector &shape_in, const std::vector &shape_out, diff --git a/mindspore/lite/tools/optimizer/graph/transpose_strategy.cc b/mindspore/lite/tools/optimizer/graph/transpose_strategy.cc index 27a48a21bcd..a8a94d28f12 100644 --- a/mindspore/lite/tools/optimizer/graph/transpose_strategy.cc +++ b/mindspore/lite/tools/optimizer/graph/transpose_strategy.cc @@ -136,6 +136,7 @@ STATUS ChangeCommonOp(const FuncGraphPtr &func_graph, const CNodePtr &cnode, For if (prim->GetAttr(ops::kAxis) == nullptr) { return lite::RET_NOT_SUPPORT; } + MS_CHECK_TRUE_MSG(prim->GetAttr(ops::kAxis) != nullptr, lite::RET_NULL_PTR, "GetAttr Failed."); auto axis = GetValue(prim->GetAttr(ops::kAxis)); if (axis < 0) { axis += kInputSizeFour; @@ -160,17 +161,21 @@ STATUS ChangeOpCrop(const FuncGraphPtr &func_graph, const CNodePtr &cnode, Forma MS_LOG(ERROR) << "cnode is invalid."; return lite::RET_ERROR; } + MS_CHECK_TRUE_RET(crop_prim->GetAttr(ops::kAxis) != nullptr, lite::RET_ERROR); auto axis = crop_prim->get_axis(); if (axis < 0) { axis += kInputSizeFour; } MS_ASSERT(axis >= 0 && axis < kInputSizeFour); + MS_CHECK_TRUE_RET(crop_prim->GetAttr(ops::kOffsets) != nullptr, lite::RET_ERROR); auto offsets = crop_prim->get_offsets(); if (trans_type == kNCHW2NHWC) { auto new_axis = kNH2NC[axis]; if (new_axis == 0) { + MS_CHECK_GE(offsets.size(), kInputIndexFour, lite::RET_ERROR); offsets = {offsets[0], offsets[kInputIndexTwo], offsets[kInputIndexThree], offsets[1]}; } else if (new_axis == kInputIndexThree) { + MS_CHECK_GE(offsets.size(), kInputIndexThree, lite::RET_ERROR); offsets = {offsets[1], offsets[kInputIndexTwo], offsets[0]}; } else { offsets.push_back(0); @@ -238,7 +243,10 @@ STATUS ChangeOpPad(const FuncGraphPtr &func_graph, const CNodePtr &cnode, Format } auto param_node = BuildIntVec2DParameterNode(func_graph, padding_list, cnode->input(kInputIndexTwo)->fullname_with_scope()); - func_graph->manager()->Replace(cnode->input(kInputIndexTwo), param_node); + MS_CHECK_TRUE_MSG(param_node != nullptr, lite::RET_NULL_PTR, "BuildParameterNode Failed"); + auto manager = func_graph->manager(); + MS_ASSERT(manager != nullptr); + manager->Replace(cnode->input(kInputIndexTwo), param_node); auto prim = GetValueNode(cnode->input(0)); MS_CHECK_TRUE_MSG(prim != nullptr, lite::RET_NULL_PTR, "GetValueNode Failed"); if (prim->GetAttr(ops::kPaddings) != nullptr) { @@ -280,7 +288,10 @@ STATUS ChangeOpSlice(const FuncGraphPtr &func_graph, const CNodePtr &cnode, Form [](int64_t v) { return static_cast(v); }); } for (size_t i = 2; i < cnode->size(); ++i) { - TransformAttrByAxes(func_graph, cnode, i, axes, trans_type, node_infer_shape); + if (TransformAttrByAxes(func_graph, cnode, i, axes, trans_type, node_infer_shape) != RET_OK) { + MS_LOG(ERROR) << "Transform axes failed."; + return RET_ERROR; + } } auto tmp_axes = TransformOpAxesAttr(axes, trans_type); std::vector new_axes(tmp_axes.begin(), tmp_axes.end()); @@ -312,13 +323,18 @@ STATUS ChangeOpStrideSlice(const FuncGraphPtr &func_graph, const CNodePtr &cnode if (index == kInputIndexFour) { continue; } - TransformAttrByAxes(func_graph, cnode, index, axes, trans_type, node_infer_shape); + if (TransformAttrByAxes(func_graph, cnode, index, axes, trans_type, node_infer_shape) != RET_OK) { + MS_LOG(ERROR) << "transform axes failed."; + return lite::RET_ERROR; + } } auto cur_axes = TransformOpAxesAttr(axes, trans_type); auto param_node = BuildIntVecParameterNode(func_graph, cur_axes, cnode->input(kInputIndexFour)->fullname_with_scope()); MS_CHECK_TRUE_MSG(param_node != nullptr, RET_ERROR, "BuildIntVecParameterNode failed"); - func_graph->manager()->Replace(cnode->input(kInputIndexFour), param_node); + auto manager = func_graph->manager(); + MS_ASSERT(manager != nullptr); + manager->Replace(cnode->input(kInputIndexFour), param_node); return lite::RET_OK; } } // namespace @@ -481,6 +497,7 @@ STATUS TransposeStrategy::TransposeInsertDependOnShape(const FuncGraphPtr &func_ return lite::RET_ERROR; } CNodePtr base_node = before ? cnode : node_users.front().first->cast(); + MS_ASSERT(base_node != nullptr); size_t input_index = before ? index : node_users.front().second; auto shape = node_infer_shape_.GetInputShape(base_node, input_index); if (!shape.empty() && shape.size() != kNH2NC.size()) { @@ -522,7 +539,7 @@ bool TransposeStrategy::IsInOutCanFuison(const FuncGraphPtr &func_graph, const s return true; } -void TransposeStrategy::DecidePreAndPostTransType(TransTypePair *trans_info, TransTypePair *trans_insert_info) { +void TransposeStrategy::DecidePreAndPostTransType(TransTypePair *trans_info, TransTypePair *trans_insert_info) const { if (trans_info->pre_ == trans_info->post_) { return; } diff --git a/mindspore/lite/tools/optimizer/graph/transpose_strategy.h b/mindspore/lite/tools/optimizer/graph/transpose_strategy.h index 50443519406..111954d69d8 100644 --- a/mindspore/lite/tools/optimizer/graph/transpose_strategy.h +++ b/mindspore/lite/tools/optimizer/graph/transpose_strategy.h @@ -50,7 +50,7 @@ class TransposeStrategy { STATUS TransposeInsertDependOnShape(const FuncGraphPtr &func_graph, const CNodePtr &cnode, bool before, size_t index); bool IsInOutCanFuison(const FuncGraphPtr &func_graph, const std::vector &nodes, size_t *trans_count, FormatTransNodeType *trans_type); - void DecidePreAndPostTransType(TransTypePair *trans_info, TransTypePair *trans_insert_info); + void DecidePreAndPostTransType(TransTypePair *trans_info, TransTypePair *trans_insert_info) const; FmkType fmk_type_{converter::kFmkTypeMs}; bool train_flag_{false}; NodeInferShape node_infer_shape_; diff --git a/mindspore/lite/tools/optimizer/graph/unused_cast_node_remove_pass.cc b/mindspore/lite/tools/optimizer/graph/unused_cast_node_remove_pass.cc index 5d97724ef99..f047ad9b425 100644 --- a/mindspore/lite/tools/optimizer/graph/unused_cast_node_remove_pass.cc +++ b/mindspore/lite/tools/optimizer/graph/unused_cast_node_remove_pass.cc @@ -24,7 +24,7 @@ void RemoveUnusedCastOpPass::SetFmkType(FmkType type) { this->fmk_type = type; } bool RemoveUnusedCastOpPass::Run(const FuncGraphPtr &func_graph) { if (this->fmk_type != converter::kFmkTypeMs) { MS_LOG(ERROR) << "The framework type of model should be mindspore."; - return RET_ERROR; + return false; } MS_ASSERT(func_graph != nullptr); auto manager = func_graph->manager(); @@ -42,12 +42,12 @@ bool RemoveUnusedCastOpPass::Run(const FuncGraphPtr &func_graph) { auto abstract_base = cast_cnode->input(1)->abstract(); if (abstract_base == nullptr) { MS_LOG(ERROR) << "Abstract of parameter is nullptr, " << cast_cnode->input(1)->fullname_with_scope(); - return RET_ERROR; + return false; } if (!utils::isa(abstract_base)) { MS_LOG(ERROR) << "Abstract of parameter should be abstract tensor, " << cast_cnode->input(1)->fullname_with_scope(); - return RET_ERROR; + return false; } auto abstract_tensor = utils::cast(abstract_base); auto input_type = abstract_tensor->element()->GetTypeTrack(); @@ -56,12 +56,12 @@ bool RemoveUnusedCastOpPass::Run(const FuncGraphPtr &func_graph) { if (cast_cnode->inputs().size() != kCastInputNum || !utils::isa(cast_cnode->input(2))) { MS_LOG(ERROR) << "Second input of cast should be a ValueNode"; - return RET_ERROR; + return false; } auto output_type = GetValueNode(cast_cnode->input(2)); if (output_type == nullptr) { MS_LOG(ERROR) << "Second input of cast is nullptr"; - return RET_ERROR; + return false; } auto output_type_value = output_type->type_id(); if ((input_type_value == kNumberTypeFloat32 && output_type_value == kNumberTypeFloat16) || diff --git a/mindspore/lite/tools/optimizer/graph/unused_transpose_node_remove_pass.cc b/mindspore/lite/tools/optimizer/graph/unused_transpose_node_remove_pass.cc index 10e847f801c..e54d6ab5fda 100644 --- a/mindspore/lite/tools/optimizer/graph/unused_transpose_node_remove_pass.cc +++ b/mindspore/lite/tools/optimizer/graph/unused_transpose_node_remove_pass.cc @@ -19,6 +19,7 @@ #include "ops/transpose.h" #include "tools/optimizer/common/gllo_utils.h" #include "include/errorcode.h" +#include "nnacl/op_base.h" namespace mindspore::opt { constexpr size_t kTransposeInput = 1; @@ -60,7 +61,7 @@ std::vector GetTransposePerm(const CNodePtr &node) { bool RemoveUnusedTransposeOpPass::Run(const FuncGraphPtr &func_graph) { if (this->fmk_type != converter::kFmkTypeOnnx) { MS_LOG(ERROR) << "The framework type of model should be onnx."; - return RET_ERROR; + return false; } MS_ASSERT(func_graph != nullptr); auto manager = func_graph->manager(); diff --git a/mindspore/lite/tools/optimizer/graph/update_conv2d_param_pass.cc b/mindspore/lite/tools/optimizer/graph/update_conv2d_param_pass.cc index b19a329a8a0..671c662d4ce 100644 --- a/mindspore/lite/tools/optimizer/graph/update_conv2d_param_pass.cc +++ b/mindspore/lite/tools/optimizer/graph/update_conv2d_param_pass.cc @@ -67,6 +67,7 @@ STATUS UpdateConv2DParamPass::UpdateConv2DAttr(const CNodePtr &cnode) { return lite::RET_ERROR; } auto prim = GetValueNode(cnode->input(0)); + MS_ASSERT(prim != nullptr); if (prim->GetAttr(ops::kFormat) == nullptr) { MS_LOG(ERROR) << "current conv2d's format is undefined."; return lite::RET_ERROR; @@ -85,6 +86,7 @@ STATUS UpdateConv2DParamPass::UpdateConv2DAttr(const CNodePtr &cnode) { prim->GetAttr(ops::kIsDepthWise) != nullptr && GetValue(prim->GetAttr(ops::kIsDepthWise)); prim->AddAttr(ops::kGroup, MakeValue(is_depth_wise ? out_channel : 1)); } + MS_ASSERT(prim->GetAttr(ops::kGroup) != nullptr); auto group = GetValue(prim->GetAttr(ops::kGroup)); if (CheckPrimitiveType(cnode, prim::kPrimConv2dTransposeFusion)) { std::swap(in_channel, out_channel); @@ -101,8 +103,6 @@ STATUS UpdateConv2DParamPass::UpdateConv2DAttr(const CNodePtr &cnode) { bool UpdateConv2DParamPass::Run(const FuncGraphPtr &func_graph) { MS_ASSERT(func_graph != nullptr); - auto manager = func_graph->manager(); - MS_ASSERT(manager != nullptr); auto node_list = TopoSort(func_graph->get_return()); for (auto &node : node_list) { if (!utils::isa(node)) { diff --git a/mindspore/lite/tools/optimizer/parallel/conv2d_info.cc b/mindspore/lite/tools/optimizer/parallel/conv2d_info.cc index aa730ccc9d6..ca541fdd115 100644 --- a/mindspore/lite/tools/optimizer/parallel/conv2d_info.cc +++ b/mindspore/lite/tools/optimizer/parallel/conv2d_info.cc @@ -92,6 +92,7 @@ int Conv2DInfo::CheckStrategy(const SplitStrategy &strategy) { int Conv2DInfo::CheckIfSplit() { auto conv_prim = GetValueNode>(cnode_->input(kAnfPrimitiveIndex)); + MS_ASSERT(conv_prim != nullptr); auto strides = conv_prim->get_stride(); std::vector weight_shape; std::vector input_shape; @@ -99,7 +100,9 @@ int Conv2DInfo::CheckIfSplit() { // for n, h, cin, we should checkout it's input whether bigger than split total ratio if (split_mode_ != SplitCOUT) { auto input_node_abstract = GetCNodeInputAbstract(cnode_, 1); + MS_CHECK_TRUE_RET(input_node_abstract != nullptr, RET_ERROR); auto weight_node_abstract = GetCNodeInputAbstract(cnode_, 2); + MS_CHECK_TRUE_RET(weight_node_abstract != nullptr, RET_ERROR); if (!utils::isa(input_node_abstract)) { MS_LOG(ERROR) << "conv_input_abstract of should be abstract tensor"; return RET_ERROR; @@ -163,8 +166,11 @@ AnfNodePtr Conv2DInfo::CreateOutputsOfSplit(const CNodePtr &orig_node, size_t in MS_CHECK_GE(conv_prim->get_stride().size(), 1, nullptr); auto extend_bottom = conv_prim->get_kernel_size().at(kIndexH) - conv_prim->get_stride().at(kIndexH); auto bottom_vector = std::vector(split_num, extend_bottom); + MS_CHECK_GE(split_num, 1, nullptr); bottom_vector[split_num - 1] = 0; split_prim->set_extend_bottom(bottom_vector); + MS_CHECK_GE(conv_prim->get_pad_list().size(), 1, nullptr); + MS_CHECK_TRUE_RET(input_shape.size() == DIMENSION_4D, nullptr); if (!UpdateRatioWithPadStride(new_splits.data(), new_splits.size(), split_num, input_shape[split_dim], conv_prim->get_pad_list().at(kPadUp), conv_prim->get_stride().at(kIndexH))) { MS_LOG(ERROR) << "UpdateRatioWithPadStride failed"; @@ -178,7 +184,9 @@ AnfNodePtr Conv2DInfo::CreateOutputsOfSplit(const CNodePtr &orig_node, size_t in split_prim->set_number_split(split_num); split_prim->set_ratio(new_splits); - std::vector split_inputs = {NewValueNode(split_prim)}; + auto split_primitive = NewValueNode(split_prim); + MS_CHECK_TRUE_MSG(split_primitive != nullptr, nullptr, "create SplitWithOverlap return nullptr"); + std::vector split_inputs = {split_primitive}; // ori_conv_node must only have one input split_inputs.push_back(orig_node->input(input_index + 1)); auto split_cnode = func_graph_->NewCNode(split_inputs); @@ -225,7 +233,6 @@ int Conv2DInfo::InferParallelCNodes() { if (CheckIfSplit() != RET_OK) { return RET_ERROR; } - Strategys strategys = strategy_.strategys; size_t dev_num = strategy_.dev_num; std::vector feature_split_outputs; std::vector kernel_split_outputs; @@ -361,7 +368,7 @@ int Conv2DInfo::InferReplaceOp() { size_t dev_num = strategy_.dev_num; if (split_mode_ == SplitCIN) { MS_LOG(DEBUG) << name_ << " : Split Cin, infer Forward op."; - replace_op_ = CreateReduceNode(cnode_, parallel_output_nodes_, kAxisCIn, dev_num, true); + replace_op_ = CreateReduceNode(cnode_, parallel_output_nodes_, kAxisCIn, dev_num); } else { int32_t concat_dim; if (split_mode_ == SplitN) { @@ -372,7 +379,7 @@ int Conv2DInfo::InferReplaceOp() { } else { concat_dim = kAxisH; } - replace_op_ = CreateConcateNode(cnode_, parallel_output_nodes_, concat_dim, dev_num, true); + replace_op_ = CreateConcateNode(cnode_, parallel_output_nodes_, concat_dim, dev_num); } if (replace_op_ == nullptr) { diff --git a/mindspore/lite/tools/optimizer/parallel/depthwise_conv2d_info.cc b/mindspore/lite/tools/optimizer/parallel/depthwise_conv2d_info.cc index 22cd67f1073..66ba9b5b0e4 100644 --- a/mindspore/lite/tools/optimizer/parallel/depthwise_conv2d_info.cc +++ b/mindspore/lite/tools/optimizer/parallel/depthwise_conv2d_info.cc @@ -67,6 +67,11 @@ void CreateSplitConstantTensors(const tensor::TensorPtr &constant_tensor, const for (int64_t i = 0; i < split_num; i++) { // init shape for [split_dim] visited_block += splits[i]; + if (total_block_count == 0) { + MS_LOG(ERROR) << "divisor is zero"; + split_constant_tensors->clear(); + return; + } auto cur_shape = UP_DIV(split_dim_size * visited_block, total_block_count); split_constant_shapes.at(i).at(split_dim) = cur_shape; auto tensor = std::make_shared(weight_type_id, split_constant_shapes.at(i)); @@ -491,7 +496,7 @@ int DepthwiseConv2DInfo::InferParallelCNodes() { int DepthwiseConv2DInfo::InferReplaceOp() { size_t dev_num = strategy_.dev_num; - replace_op_ = CreateConcateNode(cnode_, parallel_output_nodes_, split_dim_, dev_num, true); + replace_op_ = CreateConcateNode(cnode_, parallel_output_nodes_, split_dim_, dev_num); if (replace_op_ == nullptr) { return RET_ERROR; } diff --git a/mindspore/lite/tools/optimizer/parallel/multi_conv_info.cc b/mindspore/lite/tools/optimizer/parallel/multi_conv_info.cc index 87a9ab4e770..996a304265a 100644 --- a/mindspore/lite/tools/optimizer/parallel/multi_conv_info.cc +++ b/mindspore/lite/tools/optimizer/parallel/multi_conv_info.cc @@ -80,10 +80,8 @@ bool MultiConvSplit::CheckSplitValid() { if (i >= static_cast(final_ratios.size()) || final_ratios.at(i) <= 0) { return false; } - MS_CHECK_INT_ADD_NOT_OVERFLOW(total_block_count, final_ratios.at(i), false); total_block_count += final_ratios.at(i); if (i == 0) { - MS_CHECK_INT_ADD_NOT_OVERFLOW(visited_block, final_ratios.at(i), false); visited_block += final_ratios.at(i); } } @@ -122,7 +120,8 @@ int MultiConvSplit::GetMultiConvNodes(const AnfNodePtr &conv_node) { while (index < split_info_.in_num_conv - 1) { MS_CHECK_LT(index, static_cast(conv_nodes_.size()), RET_ERROR); auto curr_node = conv_nodes_[index]; - auto curr_cnode = conv_nodes_[index]->cast(); + MS_ASSERT(curr_node != nullptr); + auto curr_cnode = curr_node->cast(); MS_CHECK_TRUE_RET(curr_cnode != nullptr, RET_ERROR); auto tmp_node = curr_cnode->input(1); if (!IsConv2D(tmp_node)) { @@ -198,7 +197,7 @@ bool MultiConvSplit::SplitSingleConv(const AnfNodePtr &ori_node, const std::vect // node inputs std::vector conv_inputs; conv_inputs.push_back(NewValueNode(conv_prim)); - AdJustInputs(ori_node, inputs_node, weight_nodes, bias_nodes, output_conv_index, &conv_inputs); + AdJustInputs(ori_node, inputs_node, output_conv_index, &conv_inputs); // create new conv node if (!CreateNewConvNode(ori_node, conv_inputs, output_conv_index, outputs_node)) { return false; @@ -208,7 +207,6 @@ bool MultiConvSplit::SplitSingleConv(const AnfNodePtr &ori_node, const std::vect } void MultiConvSplit::AdJustInputs(const AnfNodePtr &ori_conv_node, const std::vector &new_inputs_node, - const std::vector &weight_node, const std::vector &bias_nodes, int output_conv_index, std::vector *conv_inputs) { MS_ASSERT(ori_conv_node != nullptr && conv_inputs != nullptr); auto ori_conv_cnode = ori_conv_node->cast(); diff --git a/mindspore/lite/tools/optimizer/parallel/multi_conv_info.h b/mindspore/lite/tools/optimizer/parallel/multi_conv_info.h index 0787abfe725..31d24d3c248 100644 --- a/mindspore/lite/tools/optimizer/parallel/multi_conv_info.h +++ b/mindspore/lite/tools/optimizer/parallel/multi_conv_info.h @@ -41,7 +41,6 @@ class MultiConvSplit : public MultiNodeSplit { virtual AnfNodePtr MultiConvNHSplit(const AnfNodePtr &node); virtual void AdJustInputs(const AnfNodePtr &ori_node, const std::vector &new_inputs_node, - const std::vector &weight_node, const std::vector &bias_nodes, int output_conv_index, std::vector *conv_inputs); virtual bool CreateNewConvNode(const AnfNodePtr &ori_conv_node, const std::vector &conv_inputs, diff --git a/mindspore/lite/tools/optimizer/parallel/multi_node_split.cc b/mindspore/lite/tools/optimizer/parallel/multi_node_split.cc index e24c4867078..fad75a37467 100644 --- a/mindspore/lite/tools/optimizer/parallel/multi_node_split.cc +++ b/mindspore/lite/tools/optimizer/parallel/multi_node_split.cc @@ -42,10 +42,7 @@ int MultiNodeSplitProxy::InitResource() { return RET_OK; } -int MultiNodeSplitProxy::FreeResource() { - multi_node_split_ = nullptr; - return RET_OK; -} +void MultiNodeSplitProxy::FreeResource() { multi_node_split_ = nullptr; } AnfNodePtr MultiNodeSplitProxy::DoSplit(const FuncGraphPtr &func_graph, const AnfNodePtr &node) { MS_CHECK_TRUE_RET(func_graph != nullptr, nullptr); @@ -55,10 +52,7 @@ AnfNodePtr MultiNodeSplitProxy::DoSplit(const FuncGraphPtr &func_graph, const An return node; } auto res_node = multi_node_split_->DoSplit(func_graph, node); - ret = FreeResource(); - if (ret != RET_OK) { - return node; - } + FreeResource(); return res_node; } diff --git a/mindspore/lite/tools/optimizer/parallel/multi_node_split.h b/mindspore/lite/tools/optimizer/parallel/multi_node_split.h index ace205e6cb0..c7b5324bd65 100644 --- a/mindspore/lite/tools/optimizer/parallel/multi_node_split.h +++ b/mindspore/lite/tools/optimizer/parallel/multi_node_split.h @@ -46,7 +46,7 @@ class MultiNodeSplitProxy : public MultiNodeSplit { private: int InitResource(); - int FreeResource(); + void FreeResource(); private: SplitMode split_mode_{NoSplit}; diff --git a/mindspore/lite/tools/optimizer/parallel/operator_info.cc b/mindspore/lite/tools/optimizer/parallel/operator_info.cc index 48f8d46ddcb..f26c641ddbc 100644 --- a/mindspore/lite/tools/optimizer/parallel/operator_info.cc +++ b/mindspore/lite/tools/optimizer/parallel/operator_info.cc @@ -35,7 +35,7 @@ bool is_any_not_none(const std::vector &split) { return std::any_of(split.begin(), split.end(), [](int64_t v) { return v != static_cast(NoSplit); }); } -std::shared_ptr OperatorInfo::CreateFakeAbstractTensor() { +std::shared_ptr OperatorInfo::CreateFakeAbstractTensor() const { auto type_ptr = TypeIdToType(operator_type_id_); std::vector shape_vector; return std::make_shared(type_ptr, shape_vector); @@ -135,7 +135,7 @@ int OperatorInfo::CreateMultipleOutputsOfAnfNode(const AnfNodePtr &node, size_t } AnfNodePtr OperatorInfo::CreateConcateNode(const CNodePtr &orig_node, const std::vector &input_nodes, - int32_t concat_dim, size_t input_nodes_num, bool trans_format) { + int32_t concat_dim, size_t input_nodes_num) { MS_EXCEPTION_IF_NULL(orig_node); if (input_nodes.size() != input_nodes_num) { MS_LOG(ERROR) << name_ << " : Input nodes size of concat is not equal to input nodes number."; @@ -162,7 +162,7 @@ AnfNodePtr OperatorInfo::CreateConcateNode(const CNodePtr &orig_node, const std: } AnfNodePtr OperatorInfo::CreateReduceNode(const CNodePtr &orig_node, const std::vector &input_nodes, - int32_t reduce_dim, size_t input_nodes_num, bool trans_format) { + int32_t reduce_dim, size_t input_nodes_num) { MS_EXCEPTION_IF_NULL(orig_node); if (input_nodes.size() != input_nodes_num) { MS_LOG(ERROR) << name_ << " : Input nodes size of reduce is not equal to input nodes number."; diff --git a/mindspore/lite/tools/optimizer/parallel/operator_info.h b/mindspore/lite/tools/optimizer/parallel/operator_info.h index dacc4bfa870..33c415b664a 100644 --- a/mindspore/lite/tools/optimizer/parallel/operator_info.h +++ b/mindspore/lite/tools/optimizer/parallel/operator_info.h @@ -65,11 +65,11 @@ class OperatorInfo { int CreateMultipleOutputsOfAnfNode(const AnfNodePtr &node, size_t output_num, std::vector *outputs); AnfNodePtr CreateConcateNode(const CNodePtr &orig_node, const std::vector &input_nodes, - int32_t concat_dim, size_t input_nodes_num, bool trans_format); + int32_t concat_dim, size_t input_nodes_num); AnfNodePtr CreateReduceNode(const CNodePtr &orig_node, const std::vector &input_nodes, int32_t reduce_dim, - size_t input_nodes_num, bool trans_format); + size_t input_nodes_num); - std::shared_ptr CreateFakeAbstractTensor(); + std::shared_ptr CreateFakeAbstractTensor() const; virtual AnfNodePtr CreateOutputsOfSplit(const CNodePtr &input_node, size_t input_index, std::vector *split_outputs, size_t split_dim, size_t split_num, diff --git a/mindspore/lite/tools/optimizer/parallel/operator_info_register.cc b/mindspore/lite/tools/optimizer/parallel/operator_info_register.cc index b7a1ba24ba1..d99d46a1a3d 100644 --- a/mindspore/lite/tools/optimizer/parallel/operator_info_register.cc +++ b/mindspore/lite/tools/optimizer/parallel/operator_info_register.cc @@ -37,16 +37,15 @@ OperatorInfoFactory *OperatorInfoFactory::GeInstance() { return &factory; } -int OperatorInfoFactory::RegisterOperatorInfo(schema::PrimitiveType operator_type, TypeId type_id, bool is_depth_wise, - const OperatorInfoCreatorFunc &creator_func) { +void OperatorInfoFactory::RegisterOperatorInfo(schema::PrimitiveType operator_type, TypeId type_id, bool is_depth_wise, + const OperatorInfoCreatorFunc &creator_func) { // create a key to find the only create function SplitOpKey op_key(operator_type, type_id, is_depth_wise); if (operator_info_map_.find(op_key) != operator_info_map_.end()) { MS_LOG(ERROR) << " Operator already exist " << op_key.ToString(); - return lite::RET_ERROR; + return; } this->operator_info_map_.insert(std::pair(op_key, creator_func)); - return lite::RET_OK; } OperatorInfoCreatorFunc OperatorInfoFactory::FindOperatorInfo(const SplitOpKey &op_key) { diff --git a/mindspore/lite/tools/optimizer/parallel/operator_info_register.h b/mindspore/lite/tools/optimizer/parallel/operator_info_register.h index 1c73f8b5f57..c25a0655f24 100644 --- a/mindspore/lite/tools/optimizer/parallel/operator_info_register.h +++ b/mindspore/lite/tools/optimizer/parallel/operator_info_register.h @@ -56,8 +56,8 @@ class OperatorInfoFactory { OperatorInfoFactory &operator=(const OperatorInfoFactory &) = delete; - int RegisterOperatorInfo(schema::PrimitiveType operator_type, TypeId type_id, bool is_depth_wise, - const OperatorInfoCreatorFunc &creator_func); + void RegisterOperatorInfo(schema::PrimitiveType operator_type, TypeId type_id, bool is_depth_wise, + const OperatorInfoCreatorFunc &creator_func); OperatorInfoCreatorFunc FindOperatorInfo(const SplitOpKey &split_op_key); diff --git a/mindspore/lite/tools/optimizer/parallel/parallel_pass.cc b/mindspore/lite/tools/optimizer/parallel/parallel_pass.cc index 16c57517c3e..b098b69b4f5 100644 --- a/mindspore/lite/tools/optimizer/parallel/parallel_pass.cc +++ b/mindspore/lite/tools/optimizer/parallel/parallel_pass.cc @@ -104,6 +104,7 @@ AnfNodePtr ParallelPass::Run(const FuncGraphPtr &func_graph, const AnfNodePtr &n } // if current conv2d node has two output nodes ,we do not split it; auto manager = func_graph->manager(); + MS_CHECK_TRUE_MSG(manager != nullptr, nullptr, "manager is nullptr."); auto iter = manager->node_users().find(node); if (iter == manager->node_users().end()) { MS_LOG(ERROR) << "node : " << node->fullname_with_scope() << "has no output";