From ddfc7f3c023b78ce0c3ad9eb8ba52193a9c327eb Mon Sep 17 00:00:00 2001 From: liuyu Date: Fri, 30 Apr 2021 17:24:45 +0800 Subject: [PATCH] modify static check --- .../ops/populate/activation_grad_populate.cc | 24 +-- .../src/ops/populate/activation_populate.cc | 34 ++-- .../lite/src/ops/populate/adam_populate.cc | 6 +- .../lite/src/ops/populate/add_populate.cc | 19 ++- .../lite/src/ops/populate/adder_populate.cc | 67 ++++---- .../lite/src/ops/populate/addn_populate.cc | 19 ++- .../lite/src/ops/populate/argmax_populate.cc | 3 +- .../lite/src/ops/populate/argmin_populate.cc | 32 ++-- .../src/ops/populate/arithmetic_populate.cc | 6 +- .../ops/populate/arithmetic_self_populate.cc | 16 +- .../lite/src/ops/populate/assert_populate.cc | 17 +- .../src/ops/populate/assign_add_populate.cc | 6 +- .../lite/src/ops/populate/assign_populate.cc | 5 +- .../populate/audio_spectrogram_populate.cc | 26 +-- .../src/ops/populate/batch_norm_populate.cc | 30 ++-- .../ops/populate/batch_to_space_populate.cc | 46 ++--- .../src/ops/populate/bias_add_populate.cc | 18 +- .../src/ops/populate/bias_grad_populate.cc | 17 +- .../binary_cross_entropy_grad_populate.cc | 27 ++- .../populate/binary_cross_entropy_populate.cc | 21 +-- .../src/ops/populate/broadcast_to_populate.cc | 25 +-- .../lite/src/ops/populate/call_populate.cc | 16 +- .../lite/src/ops/populate/cast_populate.cc | 8 +- .../lite/src/ops/populate/clip_populate.cc | 18 +- .../lite/src/ops/populate/common_populate.cc | 18 +- .../lite/src/ops/populate/concat_populate.cc | 26 +-- .../populate/constant_of_shape_populate.cc | 40 +++-- .../lite/src/ops/populate/conv2d_populate.cc | 86 +++++----- .../ops/populate/crop_and_resize_populate.cc | 29 ++-- .../lite/src/ops/populate/crop_populate.cc | 39 +++-- .../lite/src/ops/populate/cumsum_populate.cc | 25 +-- .../custom_extract_features_populate.cc | 11 +- .../ops/populate/custom_normalize_populate.cc | 9 +- .../ops/populate/custom_predict_populate.cc | 16 +- .../src/ops/populate/deconv2d_populate.cc | 89 +++++----- .../lite/src/ops/populate/default_populate.cc | 6 +- .../ops/populate/depth_to_space_populate.cc | 24 +-- .../ops/populate/depthwise_conv2d_populate.cc | 9 +- .../detection_post_process_populate.cc | 52 +++--- .../lite/src/ops/populate/div_populate.cc | 3 +- .../lite/src/ops/populate/eltwise_populate.cc | 20 +-- .../lite/src/ops/populate/elu_populate.cc | 27 +-- .../ops/populate/embedding_lookup_populate.cc | 16 +- .../lite/src/ops/populate/exp_populate.cc | 31 ++-- .../src/ops/populate/expand_dims_populate.cc | 18 +- .../lite/src/ops/populate/fill_populate.cc | 18 +- .../lite/src/ops/populate/flatten_populate.cc | 15 +- .../ops/populate/full_connection_populate.cc | 46 ++--- .../ops/populate/fused_batchnorm_populate.cc | 24 +-- .../src/ops/populate/gather_nd_populate.cc | 18 +- .../lite/src/ops/populate/gather_populate.cc | 17 +- .../lite/src/ops/populate/gru_populate.cc | 27 ++- .../ops/populate/hashtable_lookup_populate.cc | 7 +- .../ops/populate/instance_norm_populate.cc | 21 +-- .../lite/src/ops/populate/l2_norm_populate.cc | 34 ++-- .../ops/populate/layer_norm_grad_populate.cc | 26 +-- .../src/ops/populate/layer_norm_populate.cc | 31 ++-- .../local_response_normalization_populate.cc | 26 +-- .../src/ops/populate/log_softmax_populate.cc | 28 +-- .../ops/populate/lsh_projection_populate.cc | 23 +-- .../lite/src/ops/populate/lstm_populate.cc | 31 ++-- .../lite/src/ops/populate/matmul_populate.cc | 28 +-- .../lite/src/ops/populate/merge_populate.cc | 18 +- .../lite/src/ops/populate/mfcc_populate.cc | 26 +-- .../lite/src/ops/populate/mul_populate.cc | 8 +- .../populate/non_max_suppression_populate.cc | 14 +- .../lite/src/ops/populate/one_hot_populate.cc | 22 +-- .../src/ops/populate/oneslike_populate.cc | 8 +- .../lite/src/ops/populate/p_relu_populate.cc | 15 +- .../lite/src/ops/populate/pad_populate.cc | 23 +-- .../lite/src/ops/populate/partial_populate.cc | 21 +-- .../lite/src/ops/populate/pooling_populate.cc | 161 +++++++++--------- .../lite/src/ops/populate/power_populate.cc | 30 ++-- .../src/ops/populate/prior_box_populate.cc | 60 ++++--- .../ops/populate/quant_dtype_cast_populate.cc | 24 +-- .../random_standard_normal_populate.cc | 27 +-- .../lite/src/ops/populate/range_populate.cc | 35 ++-- .../lite/src/ops/populate/rank_populate.cc | 18 +- .../lite/src/ops/populate/reduce_populate.cc | 29 ++-- .../lite/src/ops/populate/reshape_populate.cc | 18 +- .../lite/src/ops/populate/resize_populate.cc | 30 ++-- .../lite/src/ops/populate/reverse_populate.cc | 24 +-- .../ops/populate/reverse_sequence_populate.cc | 29 ++-- .../src/ops/populate/roi_pooling_populate.cc | 31 ++-- .../lite/src/ops/populate/scale_populate.cc | 24 +-- .../src/ops/populate/scatter_nd_populate.cc | 19 ++- .../lite/src/ops/populate/shape_populate.cc | 18 +- .../src/ops/populate/skip_gram_populate.cc | 25 +-- .../lite/src/ops/populate/slice_populate.cc | 22 ++- .../lite/src/ops/populate/softmax_populate.cc | 33 ++-- .../populate/space_to_batch_nd_populate.cc | 51 +++--- .../ops/populate/space_to_batch_populate.cc | 47 ++--- .../ops/populate/space_to_depth_populate.cc | 23 +-- ...parse_softmax_cross_entropy_with_logits.cc | 18 +- .../ops/populate/sparse_to_dense_populate.cc | 18 +- .../lite/src/ops/populate/splice_populate.cc | 68 ++++---- .../lite/src/ops/populate/split_populate.cc | 48 +++--- .../populate/split_with_overlap_populate.cc | 49 +++--- .../lite/src/ops/populate/squeeze_populate.cc | 39 +++-- .../lite/src/ops/populate/stack_populate.cc | 23 +-- .../populate/strided_slice_grad_populate.cc | 29 ++-- .../ops/populate/strided_slice_populate.cc | 28 +-- .../lite/src/ops/populate/sub_populate.cc | 8 +- .../lite/src/ops/populate/switch_populate.cc | 18 +- .../populate/tensorlistfromtensor_populate.cc | 24 +-- .../populate/tensorlistgetitem_populate.cc | 22 +-- .../populate/tensorlistreserve_populate.cc | 22 +-- .../populate/tensorlistsetlitem_populate.cc | 22 +-- .../ops/populate/tensorliststack_populate.cc | 24 +-- .../lite/src/ops/populate/tile_populate.cc | 22 +-- .../lite/src/ops/populate/topk_populate.cc | 27 +-- .../src/ops/populate/transpose_populate.cc | 18 +- .../src/ops/populate/uniform_real_populate.cc | 26 +-- .../lite/src/ops/populate/unique_populate.cc | 18 +- .../populate/unsorted_segment_sum_populate.cc | 8 +- .../src/ops/populate/unsqueeze_populate.cc | 35 ++-- .../lite/src/ops/populate/unstack_populate.cc | 22 +-- .../populate/v0/broadcast_to_populate_v0.cc | 1 + .../src/ops/populate/v0/common_populate_v0.cc | 6 +- .../v0/constant_of_shape_populate_v0.cc | 9 +- .../ops/populate/v0/l2_norm_populate_v0.cc | 1 + .../ops/populate/v0/prior_box_populate_v0.cc | 4 + .../src/ops/populate/v0/reduce_populate_v0.cc | 5 +- .../ops/populate/v0/reverse_populate_v0.cc | 5 +- .../src/ops/populate/v0/slice_populate_v0.cc | 1 + .../src/ops/populate/v0/tile_populate_v0.cc | 12 +- .../ops/populate/v0/transpose_populate_v0.cc | 5 +- .../lite/src/ops/populate/where_populate.cc | 21 +-- .../lite/src/ops/populate/while_populate.cc | 24 +-- 129 files changed, 1682 insertions(+), 1501 deletions(-) diff --git a/mindspore/lite/src/ops/populate/activation_grad_populate.cc b/mindspore/lite/src/ops/populate/activation_grad_populate.cc index 9d3145df4c..8c6290f49c 100644 --- a/mindspore/lite/src/ops/populate/activation_grad_populate.cc +++ b/mindspore/lite/src/ops/populate/activation_grad_populate.cc @@ -20,13 +20,6 @@ using mindspore::schema::PrimitiveType_ActivationGrad; namespace mindspore { namespace lite { OpParameter *PopulateActivationGradParameter(const void *prim) { - auto *act_param = reinterpret_cast(malloc(sizeof(ActivationGradParameter))); - if (act_param == nullptr) { - MS_LOG(ERROR) << "malloc ActivationParameter failed."; - return nullptr; - } - memset(act_param, 0, sizeof(ActivationGradParameter)); - auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_ActivationGrad(); @@ -34,11 +27,20 @@ OpParameter *PopulateActivationGradParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - act_param->op_parameter.type_ = primitive->value_type(); - act_param->type_ = static_cast(value->activation_type()); - act_param->alpha_ = value->alpha(); - return reinterpret_cast(act_param); + + auto *param = reinterpret_cast(malloc(sizeof(ActivationGradParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc ActivationParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(ActivationGradParameter)); + + param->op_parameter.type_ = primitive->value_type(); + param->type_ = static_cast(value->activation_type()); + param->alpha_ = value->alpha(); + return reinterpret_cast(param); } + REG_POPULATE(PrimitiveType_ActivationGrad, PopulateActivationGradParameter, SCHEMA_CUR); } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/activation_populate.cc b/mindspore/lite/src/ops/populate/activation_populate.cc index 73ee9fa91c..cfb58cd630 100644 --- a/mindspore/lite/src/ops/populate/activation_populate.cc +++ b/mindspore/lite/src/ops/populate/activation_populate.cc @@ -19,29 +19,29 @@ using mindspore::schema::PrimitiveType_Activation; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateRelu6Parameter(const void *prim) { - auto *act_param = reinterpret_cast(malloc(sizeof(ActivationParameter))); - if (act_param == nullptr) { - MS_LOG(ERROR) << "malloc ActivationParameter failed."; - return nullptr; - } - memset(act_param, 0, sizeof(ActivationParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - act_param->op_parameter_.type_ = primitive->value_type(); - auto acti_prim = primitive->value_as_Activation(); - if (acti_prim == nullptr) { - MS_LOG(ERROR) << "acti_prim is nullptr"; + auto value = primitive->value_as_Activation(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } + + auto *param = reinterpret_cast(malloc(sizeof(ActivationParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc ActivationParameter failed."; return nullptr; } - act_param->type_ = static_cast(acti_prim->activation_type()); - act_param->alpha_ = acti_prim->alpha(); - act_param->min_val_ = acti_prim->min_val(); - act_param->max_val_ = acti_prim->max_val(); - return reinterpret_cast(act_param); + memset(param, 0, sizeof(ActivationParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->type_ = static_cast(value->activation_type()); + param->alpha_ = value->alpha(); + param->min_val_ = value->min_val(); + param->max_val_ = value->max_val(); + return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_Activation, PopulateRelu6Parameter, SCHEMA_CUR) } // namespace lite diff --git a/mindspore/lite/src/ops/populate/adam_populate.cc b/mindspore/lite/src/ops/populate/adam_populate.cc index 981821a5bd..91ef60ab86 100644 --- a/mindspore/lite/src/ops/populate/adam_populate.cc +++ b/mindspore/lite/src/ops/populate/adam_populate.cc @@ -19,14 +19,16 @@ using mindspore::schema::PrimitiveType_Adam; namespace mindspore { namespace lite { OpParameter *PopulateAdamParameter(const void *prim) { + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + auto *param = reinterpret_cast(malloc(sizeof(OpParameter))); if (param == nullptr) { MS_LOG(ERROR) << "malloc Adam Parameter failed."; return nullptr; } memset(param, 0, sizeof(OpParameter)); - auto primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); + param->type_ = primitive->value_type(); return param; } diff --git a/mindspore/lite/src/ops/populate/add_populate.cc b/mindspore/lite/src/ops/populate/add_populate.cc index eaa56fc46c..42dc6ee7ad 100644 --- a/mindspore/lite/src/ops/populate/add_populate.cc +++ b/mindspore/lite/src/ops/populate/add_populate.cc @@ -20,24 +20,25 @@ using mindspore::schema::PrimitiveType_AddFusion; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateAddParameter(const void *prim) { + auto *primitive = static_cast(prim); + auto value = primitive->value_as_AddFusion(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } + ArithmeticParameter *param = PopulateArithmeticCommonPara(prim); if (param == nullptr) { MS_LOG(ERROR) << "PopulateArithmeticCommonPara failed."; return nullptr; } - auto *primitive = static_cast(prim); + param->op_parameter_.type_ = primitive->value_type(); - auto add_prim = primitive->value_as_AddFusion(); - if (add_prim == nullptr) { - MS_LOG(ERROR) << "add_prim is nullptr"; - return nullptr; - } - param->activation_type_ = add_prim->activation_type(); + param->activation_type_ = value->activation_type(); return reinterpret_cast(param); } -} // namespace + REG_POPULATE(PrimitiveType_AddFusion, PopulateAddParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/adder_populate.cc b/mindspore/lite/src/ops/populate/adder_populate.cc index e2a1953d9e..284b632448 100644 --- a/mindspore/lite/src/ops/populate/adder_populate.cc +++ b/mindspore/lite/src/ops/populate/adder_populate.cc @@ -21,56 +21,59 @@ using mindspore::schema::PrimitiveType_AdderFusion; namespace mindspore { namespace lite { OpParameter *PopulateAdderParameter(const void *prim) { - ConvParameter *conv_param = reinterpret_cast(malloc(sizeof(ConvParameter))); - if (conv_param == nullptr) { - MS_LOG(ERROR) << "malloc ConvParameter failed."; + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + auto value = primitive->value_as_AdderFusion(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - memset(conv_param, 0, sizeof(ConvParameter)); - auto primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); - conv_param->op_parameter_.type_ = primitive->value_type(); - auto conv_primitive = primitive->value_as_AdderFusion(); - if (conv_primitive == nullptr) { - MS_LOG(ERROR) << "conv_primitive is nullptr"; + auto *param = reinterpret_cast(malloc(sizeof(ConvParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc ConvParameter failed."; return nullptr; } - auto kernel_size = conv_primitive->kernel_size(); - auto stride = conv_primitive->stride(); - auto pad_list = conv_primitive->pad_list(); - auto dilation = conv_primitive->dilation(); + memset(param, 0, sizeof(ConvParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + auto kernel_size = value->kernel_size(); + auto stride = value->stride(); + auto pad_list = value->pad_list(); + auto dilation = value->dilation(); if (kernel_size == nullptr || stride == nullptr || pad_list == nullptr || dilation == nullptr) { MS_LOG(ERROR) << "nullptr"; + free(param); return nullptr; } - conv_param->kernel_h_ = static_cast(*(kernel_size->begin())); - conv_param->kernel_w_ = static_cast(*(kernel_size->begin() + 1)); - conv_param->group_ = static_cast(conv_primitive->group()); - conv_param->stride_h_ = static_cast(*(stride->begin())); - conv_param->stride_w_ = static_cast(*(stride->begin() + 1)); - conv_param->pad_u_ = static_cast(*(pad_list->begin())); - conv_param->pad_d_ = static_cast(*(pad_list->begin() + 1)); - conv_param->pad_l_ = static_cast(*(pad_list->begin() + 2)); - conv_param->pad_r_ = static_cast(*(pad_list->begin() + 3)); - conv_param->dilation_h_ = static_cast(*(dilation->begin())); - conv_param->dilation_w_ = static_cast(*(dilation->begin() + 1)); - conv_param->input_channel_ = static_cast(conv_primitive->in_channel()); - conv_param->output_channel_ = static_cast(conv_primitive->out_channel()); - auto act_type = conv_primitive->activation_type(); + param->kernel_h_ = static_cast(*(kernel_size->begin())); + param->kernel_w_ = static_cast(*(kernel_size->begin() + 1)); + param->group_ = static_cast(value->group()); + param->stride_h_ = static_cast(*(stride->begin())); + param->stride_w_ = static_cast(*(stride->begin() + 1)); + param->pad_u_ = static_cast(*(pad_list->begin())); + param->pad_d_ = static_cast(*(pad_list->begin() + 1)); + param->pad_l_ = static_cast(*(pad_list->begin() + 2)); + param->pad_r_ = static_cast(*(pad_list->begin() + 3)); + param->dilation_h_ = static_cast(*(dilation->begin())); + param->dilation_w_ = static_cast(*(dilation->begin() + 1)); + param->input_channel_ = static_cast(value->in_channel()); + param->output_channel_ = static_cast(value->out_channel()); + auto act_type = value->activation_type(); switch (act_type) { case schema::ActivationType_RELU: - conv_param->act_type_ = ActType_Relu; + param->act_type_ = ActType_Relu; break; case schema::ActivationType_RELU6: - conv_param->act_type_ = ActType_Relu6; + param->act_type_ = ActType_Relu6; break; default: - conv_param->act_type_ = ActType_No; + param->act_type_ = ActType_No; break; } - return reinterpret_cast(conv_param); + return reinterpret_cast(param); } + REG_POPULATE(PrimitiveType_AdderFusion, PopulateAdderParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/addn_populate.cc b/mindspore/lite/src/ops/populate/addn_populate.cc index e52041d71e..27f0ce5881 100644 --- a/mindspore/lite/src/ops/populate/addn_populate.cc +++ b/mindspore/lite/src/ops/populate/addn_populate.cc @@ -19,20 +19,21 @@ using mindspore::schema::PrimitiveType_AddN; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateAddNParameter(const void *prim) { - auto *addn_param = reinterpret_cast(malloc(sizeof(OpParameter))); - if (addn_param == nullptr) { + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + + auto *param = reinterpret_cast(malloc(sizeof(OpParameter))); + if (param == nullptr) { MS_LOG(ERROR) << "malloc OpParameter failed."; return nullptr; } - memset(addn_param, 0, sizeof(OpParameter)); - auto primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); - addn_param->type_ = primitive->value_type(); - return reinterpret_cast(addn_param); + memset(param, 0, sizeof(OpParameter)); + + param->type_ = primitive->value_type(); + return reinterpret_cast(param); } -} // namespace + REG_POPULATE(PrimitiveType_AddN, PopulateAddNParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/argmax_populate.cc b/mindspore/lite/src/ops/populate/argmax_populate.cc index baf8aad96e..52a68c4eec 100644 --- a/mindspore/lite/src/ops/populate/argmax_populate.cc +++ b/mindspore/lite/src/ops/populate/argmax_populate.cc @@ -19,7 +19,6 @@ using mindspore::schema::PrimitiveType_ArgMaxFusion; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateArgMaxParameter(const void *prim) { auto *arg_param = reinterpret_cast(malloc(sizeof(ArgMinMaxParameter))); if (arg_param == nullptr) { @@ -32,6 +31,7 @@ OpParameter *PopulateArgMaxParameter(const void *prim) { auto param = primitive->value_as_ArgMaxFusion(); if (param == nullptr) { MS_LOG(ERROR) << "param is nullptr"; + free(arg_param); return nullptr; } arg_param->axis_ = param->axis(); @@ -41,7 +41,6 @@ OpParameter *PopulateArgMaxParameter(const void *prim) { arg_param->get_max_ = true; return reinterpret_cast(arg_param); } -} // namespace REG_POPULATE(PrimitiveType_ArgMaxFusion, PopulateArgMaxParameter, SCHEMA_CUR) } // namespace lite diff --git a/mindspore/lite/src/ops/populate/argmin_populate.cc b/mindspore/lite/src/ops/populate/argmin_populate.cc index 19e0106c07..d48dc574bb 100644 --- a/mindspore/lite/src/ops/populate/argmin_populate.cc +++ b/mindspore/lite/src/ops/populate/argmin_populate.cc @@ -19,29 +19,29 @@ using mindspore::schema::PrimitiveType_ArgMinFusion; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateArgMinParameter(const void *prim) { - ArgMinMaxParameter *arg_param = reinterpret_cast(malloc(sizeof(ArgMinMaxParameter))); - if (arg_param == nullptr) { - MS_LOG(ERROR) << "malloc ArgMinMaxParameter failed."; + auto *primitive = static_cast(prim); + auto value = primitive->value_as_ArgMinFusion(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - memset(arg_param, 0, sizeof(ArgMinMaxParameter)); - auto *primitive = static_cast(prim); - arg_param->op_parameter_.type_ = primitive->value_type(); - auto param = primitive->value_as_ArgMinFusion(); + + auto *param = reinterpret_cast(malloc(sizeof(ArgMinMaxParameter))); if (param == nullptr) { - MS_LOG(ERROR) << "param is nullptr"; + MS_LOG(ERROR) << "malloc ArgMinMaxParameter failed."; return nullptr; } - arg_param->axis_ = param->axis(); - arg_param->topk_ = param->top_k(); - arg_param->out_value_ = param->out_max_value(); - arg_param->keep_dims_ = param->keep_dims(); - arg_param->get_max_ = false; - return reinterpret_cast(arg_param); + memset(param, 0, sizeof(ArgMinMaxParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->axis_ = value->axis(); + param->topk_ = value->top_k(); + param->out_value_ = value->out_max_value(); + param->keep_dims_ = value->keep_dims(); + param->get_max_ = false; + return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_ArgMinFusion, PopulateArgMinParameter, SCHEMA_CUR) } // namespace lite diff --git a/mindspore/lite/src/ops/populate/arithmetic_populate.cc b/mindspore/lite/src/ops/populate/arithmetic_populate.cc index e2f4f12e4d..f32f601932 100644 --- a/mindspore/lite/src/ops/populate/arithmetic_populate.cc +++ b/mindspore/lite/src/ops/populate/arithmetic_populate.cc @@ -36,14 +36,16 @@ using mindspore::schema::PrimitiveType_SquaredDifference; namespace mindspore { namespace lite { ArithmeticParameter *PopulateArithmeticCommonPara(const void *prim) { + auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + auto *param = reinterpret_cast(malloc(sizeof(ArithmeticParameter))); if (param == nullptr) { MS_LOG(ERROR) << "malloc ArithmeticParameter failed."; return nullptr; } memset(param, 0, sizeof(ArithmeticParameter)); - auto *primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); + param->op_parameter_.type_ = primitive->value_type(); param->broadcasting_ = false; param->ndim_ = 0; diff --git a/mindspore/lite/src/ops/populate/arithmetic_self_populate.cc b/mindspore/lite/src/ops/populate/arithmetic_self_populate.cc index 3f3fdc9584..f517b35285 100644 --- a/mindspore/lite/src/ops/populate/arithmetic_self_populate.cc +++ b/mindspore/lite/src/ops/populate/arithmetic_self_populate.cc @@ -35,16 +35,18 @@ using mindspore::schema::PrimitiveType_Square; namespace mindspore { namespace lite { OpParameter *PopulateArithmeticSelf(const void *prim) { - auto *arithmetic_self_param = reinterpret_cast(malloc(sizeof(ArithmeticSelfParameter))); - if (arithmetic_self_param == nullptr) { + auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + + auto *param = reinterpret_cast(malloc(sizeof(ArithmeticSelfParameter))); + if (param == nullptr) { MS_LOG(ERROR) << "malloc ArithmeticSelfParameter failed."; return nullptr; } - memset(arithmetic_self_param, 0, sizeof(ArithmeticSelfParameter)); - auto *primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); - arithmetic_self_param->op_parameter_.type_ = primitive->value_type(); - return reinterpret_cast(arithmetic_self_param); + memset(param, 0, sizeof(ArithmeticSelfParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + return reinterpret_cast(param); } REG_POPULATE(PrimitiveType_Abs, PopulateArithmeticSelf, SCHEMA_CUR) diff --git a/mindspore/lite/src/ops/populate/assert_populate.cc b/mindspore/lite/src/ops/populate/assert_populate.cc index 891fbef8da..82f99d7cdd 100644 --- a/mindspore/lite/src/ops/populate/assert_populate.cc +++ b/mindspore/lite/src/ops/populate/assert_populate.cc @@ -18,20 +18,21 @@ using mindspore::schema::PrimitiveType_Assert; namespace mindspore { namespace lite { - OpParameter *PopulateAssertParameter(const void *prim) { - auto *assert_parameter = reinterpret_cast(malloc(sizeof(OpParameter))); - if (assert_parameter == nullptr) { + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + + auto *param = reinterpret_cast(malloc(sizeof(OpParameter))); + if (param == nullptr) { MS_LOG(ERROR) << "malloc AssertParameter failed."; return nullptr; } - memset(assert_parameter, 0, sizeof(OpParameter)); - auto primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); - assert_parameter->type_ = primitive->value_type(); + memset(param, 0, sizeof(OpParameter)); - return reinterpret_cast(assert_parameter); + param->type_ = primitive->value_type(); + return reinterpret_cast(param); } + REG_POPULATE(PrimitiveType_Assert, PopulateAssertParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/assign_add_populate.cc b/mindspore/lite/src/ops/populate/assign_add_populate.cc index c8f0b72085..23800ad24c 100644 --- a/mindspore/lite/src/ops/populate/assign_add_populate.cc +++ b/mindspore/lite/src/ops/populate/assign_add_populate.cc @@ -19,14 +19,16 @@ using mindspore::schema::PrimitiveType_AssignAdd; namespace mindspore { namespace lite { OpParameter *PopulateAssignAddParameter(const void *prim) { + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + auto *param = reinterpret_cast(malloc(sizeof(OpParameter))); if (param == nullptr) { MS_LOG(ERROR) << "malloc AssignAdd Parameter failed."; return nullptr; } memset(param, 0, sizeof(OpParameter)); - auto primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); + param->type_ = primitive->value_type(); return param; } diff --git a/mindspore/lite/src/ops/populate/assign_populate.cc b/mindspore/lite/src/ops/populate/assign_populate.cc index c5c72dfa0c..736d63feb3 100644 --- a/mindspore/lite/src/ops/populate/assign_populate.cc +++ b/mindspore/lite/src/ops/populate/assign_populate.cc @@ -19,6 +19,9 @@ using mindspore::schema::PrimitiveType_Assign; namespace mindspore { namespace lite { OpParameter *PopulateAssignParameter(const void *prim) { + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + auto *param = reinterpret_cast(malloc(sizeof(OpParameter))); if (param == nullptr) { MS_LOG(ERROR) << "malloc Assign Parameter failed."; @@ -26,8 +29,6 @@ OpParameter *PopulateAssignParameter(const void *prim) { } memset(param, 0, sizeof(OpParameter)); - auto primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); param->type_ = primitive->value_type(); return param; } diff --git a/mindspore/lite/src/ops/populate/audio_spectrogram_populate.cc b/mindspore/lite/src/ops/populate/audio_spectrogram_populate.cc index 684fa5f8ab..9f27c1d3f8 100644 --- a/mindspore/lite/src/ops/populate/audio_spectrogram_populate.cc +++ b/mindspore/lite/src/ops/populate/audio_spectrogram_populate.cc @@ -21,25 +21,27 @@ namespace mindspore { namespace lite { namespace { OpParameter *PopulateAudioSpectrogramParameter(const void *prim) { - auto *arg_param = reinterpret_cast(malloc(sizeof(AudioSpectrogramParameter))); - if (arg_param == nullptr) { - MS_LOG(ERROR) << "malloc AudioSpectrogramParameter failed."; + auto *primitive = static_cast(prim); + auto value = primitive->value_as_AudioSpectrogram(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - memset(arg_param, 0, sizeof(AudioSpectrogramParameter)); - auto *primitive = static_cast(prim); - arg_param->op_parameter_.type_ = primitive->value_type(); - auto param = primitive->value_as_AudioSpectrogram(); + + auto *param = reinterpret_cast(malloc(sizeof(AudioSpectrogramParameter))); if (param == nullptr) { - MS_LOG(ERROR) << "param is nullptr"; + MS_LOG(ERROR) << "malloc AudioSpectrogramParameter failed."; return nullptr; } - arg_param->window_size_ = param->window_size(); - arg_param->stride_ = param->stride(); - return reinterpret_cast(arg_param); + memset(param, 0, sizeof(AudioSpectrogramParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->window_size_ = value->window_size(); + param->stride_ = value->stride(); + return reinterpret_cast(param); } } // namespace -REG_POPULATE(PrimitiveType_AudioSpectrogram, PopulateAudioSpectrogramParameter, SCHEMA_CUR); +REG_POPULATE(PrimitiveType_AudioSpectrogram, PopulateAudioSpectrogramParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/batch_norm_populate.cc b/mindspore/lite/src/ops/populate/batch_norm_populate.cc index 803933932a..e0f9fed6d0 100644 --- a/mindspore/lite/src/ops/populate/batch_norm_populate.cc +++ b/mindspore/lite/src/ops/populate/batch_norm_populate.cc @@ -19,27 +19,27 @@ using mindspore::schema::PrimitiveType_BatchNorm; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateBatchNorm(const void *prim) { - auto *batch_norm_param = reinterpret_cast(malloc(sizeof(BatchNormParameter))); - if (batch_norm_param == nullptr) { - MS_LOG(ERROR) << "malloc BatchNormParameter failed."; - return nullptr; - } - memset(batch_norm_param, 0, sizeof(BatchNormParameter)); auto *primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - batch_norm_param->op_parameter_.type_ = primitive->value_type(); - auto prim_batchnorm = primitive->value_as_BatchNorm(); - if (prim_batchnorm == nullptr) { - MS_LOG(ERROR) << "prim_batchnorm is nullptr"; + auto value = primitive->value_as_BatchNorm(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } + + auto *param = reinterpret_cast(malloc(sizeof(BatchNormParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc BatchNormParameter failed."; return nullptr; } - batch_norm_param->epsilon_ = prim_batchnorm->epsilon(); - batch_norm_param->fused_ = false; - return reinterpret_cast(batch_norm_param); + memset(param, 0, sizeof(BatchNormParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->epsilon_ = value->epsilon(); + param->fused_ = false; + return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_BatchNorm, PopulateBatchNorm, SCHEMA_CUR) } // namespace lite diff --git a/mindspore/lite/src/ops/populate/batch_to_space_populate.cc b/mindspore/lite/src/ops/populate/batch_to_space_populate.cc index 26a95b0f94..133c88799e 100644 --- a/mindspore/lite/src/ops/populate/batch_to_space_populate.cc +++ b/mindspore/lite/src/ops/populate/batch_to_space_populate.cc @@ -20,48 +20,52 @@ using mindspore::schema::PrimitiveType_BatchToSpaceND; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateBatchToSpaceParameter(const void *prim) { - auto *batch_space_param = reinterpret_cast(malloc(sizeof(BatchToSpaceParameter))); - if (batch_space_param == nullptr) { - MS_LOG(ERROR) << "malloc BatchToSpaceParameter failed."; - return nullptr; - } - memset(batch_space_param, 0, sizeof(BatchToSpaceParameter)); auto *primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - batch_space_param->op_parameter_.type_ = primitive->value_type(); - auto param = primitive->value_as_BatchToSpace(); + auto value = primitive->value_as_BatchToSpace(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } + + auto *param = reinterpret_cast(malloc(sizeof(BatchToSpaceParameter))); if (param == nullptr) { - MS_LOG(ERROR) << "param is nullptr"; + MS_LOG(ERROR) << "malloc BatchToSpaceParameter failed."; return nullptr; } - auto block_size = param->block_size(); + memset(param, 0, sizeof(BatchToSpaceParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + auto block_size = value->block_size(); if (block_size == nullptr) { - return reinterpret_cast(batch_space_param); + return reinterpret_cast(param); } auto block_shape = std::vector(block_size->begin(), block_size->end()); if (block_shape.size() != BATCH_TO_SPACE_BLOCK_SHAPE_SIZE) { MS_LOG(ERROR) << "batch_to_space blockShape size should be " << BATCH_TO_SPACE_BLOCK_SHAPE_SIZE; - free(batch_space_param); + free(param); return nullptr; } - auto crop = param->crops(); + auto crop = value->crops(); if (crop == nullptr) { MS_LOG(ERROR) << "crop is nullptr"; + free(param); return nullptr; } auto fb_crops = crop->data(); if (fb_crops == nullptr) { MS_LOG(ERROR) << "fb_crops is nullptr"; + free(param); return nullptr; } std::vector crops; - for (auto iter = fb_crops->begin(); iter != fb_crops->end(); ++iter) { - auto crops_data = (*iter)->data(); + for (auto fb_crop : *fb_crops) { + auto crops_data = fb_crop->data(); if (crops_data == nullptr) { MS_LOG(ERROR) << "crops_data is nullptr"; + free(param); return nullptr; } auto crops_vec = std::vector(crops_data->begin(), crops_data->end()); @@ -69,20 +73,20 @@ OpParameter *PopulateBatchToSpaceParameter(const void *prim) { } if (crops.size() != COMM_SHAPE_SIZE) { MS_LOG(ERROR) << "batch_to_space crops size should be " << COMM_SHAPE_SIZE; - free(batch_space_param); + free(param); return nullptr; } for (int i = 0; i < BATCH_TO_SPACE_BLOCK_SHAPE_SIZE; ++i) { - batch_space_param->block_shape_[i] = static_cast(block_shape[i]); + param->block_shape_[i] = static_cast(block_shape[i]); } for (int i = 0; i < COMM_SHAPE_SIZE; ++i) { - batch_space_param->crops_[i] = static_cast(crops[i]); + param->crops_[i] = static_cast(crops[i]); } - return reinterpret_cast(batch_space_param); + return reinterpret_cast(param); } -} // namespace + REG_POPULATE(PrimitiveType_BatchToSpace, PopulateBatchToSpaceParameter, SCHEMA_CUR) REG_POPULATE(PrimitiveType_BatchToSpaceND, PopulateBatchToSpaceParameter, SCHEMA_CUR) } // namespace lite diff --git a/mindspore/lite/src/ops/populate/bias_add_populate.cc b/mindspore/lite/src/ops/populate/bias_add_populate.cc index 5ced8d13ac..2ddc86d6aa 100644 --- a/mindspore/lite/src/ops/populate/bias_add_populate.cc +++ b/mindspore/lite/src/ops/populate/bias_add_populate.cc @@ -19,21 +19,21 @@ using mindspore::schema::PrimitiveType_BiasAdd; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateBiasAddParameter(const void *prim) { - auto *arithmetic_param = reinterpret_cast(malloc(sizeof(ArithmeticParameter))); - if (arithmetic_param == nullptr) { + auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + + auto *param = reinterpret_cast(malloc(sizeof(ArithmeticParameter))); + if (param == nullptr) { MS_LOG(ERROR) << "malloc ArithmeticParameter failed."; return nullptr; } - memset(arithmetic_param, 0, sizeof(ArithmeticParameter)); - auto *primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); - arithmetic_param->op_parameter_.type_ = primitive->value_type(); + memset(param, 0, sizeof(ArithmeticParameter)); - return reinterpret_cast(arithmetic_param); + param->op_parameter_.type_ = primitive->value_type(); + return reinterpret_cast(param); } -} // namespace + REG_POPULATE(PrimitiveType_BiasAdd, PopulateBiasAddParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/bias_grad_populate.cc b/mindspore/lite/src/ops/populate/bias_grad_populate.cc index 1127f76e80..edcfec3589 100644 --- a/mindspore/lite/src/ops/populate/bias_grad_populate.cc +++ b/mindspore/lite/src/ops/populate/bias_grad_populate.cc @@ -19,21 +19,20 @@ using mindspore::schema::PrimitiveType_BiasAddGrad; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateBiasAddGradParameter(const void *prim) { - auto *arithmetic_param = reinterpret_cast(malloc(sizeof(ArithmeticParameter))); - if (arithmetic_param == nullptr) { + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + + auto *param = reinterpret_cast(malloc(sizeof(ArithmeticParameter))); + if (param == nullptr) { MS_LOG(ERROR) << "malloc ArithmeticParameter failed."; return nullptr; } - memset(arithmetic_param, 0, sizeof(ArithmeticParameter)); + memset(param, 0, sizeof(ArithmeticParameter)); - auto primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); - arithmetic_param->op_parameter_.type_ = primitive->value_type(); - return reinterpret_cast(arithmetic_param); + param->op_parameter_.type_ = primitive->value_type(); + return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_BiasAddGrad, PopulateBiasAddGradParameter, SCHEMA_CUR); } // namespace lite diff --git a/mindspore/lite/src/ops/populate/binary_cross_entropy_grad_populate.cc b/mindspore/lite/src/ops/populate/binary_cross_entropy_grad_populate.cc index b94ecf7290..5c44e12b2f 100644 --- a/mindspore/lite/src/ops/populate/binary_cross_entropy_grad_populate.cc +++ b/mindspore/lite/src/ops/populate/binary_cross_entropy_grad_populate.cc @@ -19,27 +19,26 @@ using mindspore::schema::PrimitiveType_BinaryCrossEntropyGrad; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateBinaryCrossEntropyGradParameter(const void *prim) { - auto *bce_param = - reinterpret_cast(malloc(sizeof(BinaryCrossEntropyGradParameter))); - if (bce_param == nullptr) { - MS_LOG(ERROR) << "malloc BinaryCrossEntropyGrad Parameter failed."; - return nullptr; - } - memset(bce_param, 0, sizeof(BinaryCrossEntropyGradParameter)); auto *primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - bce_param->op_parameter_.type_ = primitive->value_type(); - auto param = primitive->value_as_BinaryCrossEntropyGrad(); - if (param == nullptr) { + auto value = primitive->value_as_BinaryCrossEntropyGrad(); + if (value == nullptr) { MS_LOG(ERROR) << "param is nullptr"; return nullptr; } - bce_param->reduction = param->reduction(); - return reinterpret_cast(bce_param); + + auto *param = reinterpret_cast(malloc(sizeof(BinaryCrossEntropyGradParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc BinaryCrossEntropyGrad Parameter failed."; + return nullptr; + } + memset(param, 0, sizeof(BinaryCrossEntropyGradParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->reduction = value->reduction(); + return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_BinaryCrossEntropyGrad, PopulateBinaryCrossEntropyGradParameter, SCHEMA_CUR); } // namespace lite diff --git a/mindspore/lite/src/ops/populate/binary_cross_entropy_populate.cc b/mindspore/lite/src/ops/populate/binary_cross_entropy_populate.cc index f4fb6e74ee..772705f989 100644 --- a/mindspore/lite/src/ops/populate/binary_cross_entropy_populate.cc +++ b/mindspore/lite/src/ops/populate/binary_cross_entropy_populate.cc @@ -20,13 +20,6 @@ using mindspore::schema::PrimitiveType_BinaryCrossEntropy; namespace mindspore { namespace lite { OpParameter *PopulateBinaryCrossEntropyParameter(const void *prim) { - BinaryCrossEntropyParameter *bce_param = - reinterpret_cast(malloc(sizeof(BinaryCrossEntropyParameter))); - if (bce_param == nullptr) { - MS_LOG(ERROR) << "malloc BinaryCrossEntropy Parameter failed."; - return nullptr; - } - memset(bce_param, 0, sizeof(BinaryCrossEntropyParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_BinaryCrossEntropy(); @@ -34,9 +27,17 @@ OpParameter *PopulateBinaryCrossEntropyParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - bce_param->op_parameter_.type_ = primitive->value_type(); - bce_param->reduction = value->reduction(); - return reinterpret_cast(bce_param); + + auto *param = reinterpret_cast(malloc(sizeof(BinaryCrossEntropyParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc BinaryCrossEntropy Parameter failed."; + return nullptr; + } + memset(param, 0, sizeof(BinaryCrossEntropyParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->reduction = value->reduction(); + return reinterpret_cast(param); } REG_POPULATE(PrimitiveType_BinaryCrossEntropy, PopulateBinaryCrossEntropyParameter, SCHEMA_CUR); diff --git a/mindspore/lite/src/ops/populate/broadcast_to_populate.cc b/mindspore/lite/src/ops/populate/broadcast_to_populate.cc index 6c1188ed20..cea6e6e3f5 100644 --- a/mindspore/lite/src/ops/populate/broadcast_to_populate.cc +++ b/mindspore/lite/src/ops/populate/broadcast_to_populate.cc @@ -20,12 +20,6 @@ using mindspore::schema::PrimitiveType_BroadcastTo; namespace mindspore { namespace lite { OpParameter *PopulateBroadcastToParameter(const void *prim) { - auto *broadcast_param = reinterpret_cast(malloc(sizeof(BroadcastToParameter))); - if (broadcast_param == nullptr) { - MS_LOG(ERROR) << "malloc BroadcastToParameter failed."; - return nullptr; - } - memset(broadcast_param, 0, sizeof(BroadcastToParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_BroadcastTo(); @@ -33,17 +27,26 @@ OpParameter *PopulateBroadcastToParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - broadcast_param->op_parameter_.type_ = primitive->value_type(); + + auto *param = reinterpret_cast(malloc(sizeof(BroadcastToParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc BroadcastToParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(BroadcastToParameter)); + + param->op_parameter_.type_ = primitive->value_type(); auto dst_shape = value->shape(); if (dst_shape == nullptr) { MS_LOG(ERROR) << "dst_shape is nullptr"; + free(param); return nullptr; } - broadcast_param->shape_size_ = dst_shape->size(); - for (size_t i = 0; i < broadcast_param->shape_size_; ++i) { - broadcast_param->shape_[i] = dst_shape->Get(i); + param->shape_size_ = dst_shape->size(); + for (size_t i = 0; i < param->shape_size_; ++i) { + param->shape_[i] = dst_shape->Get(i); } - return reinterpret_cast(broadcast_param); + return reinterpret_cast(param); } REG_POPULATE(PrimitiveType_BroadcastTo, PopulateBroadcastToParameter, SCHEMA_CUR) diff --git a/mindspore/lite/src/ops/populate/call_populate.cc b/mindspore/lite/src/ops/populate/call_populate.cc index 79bb34871f..19c25f08bc 100644 --- a/mindspore/lite/src/ops/populate/call_populate.cc +++ b/mindspore/lite/src/ops/populate/call_populate.cc @@ -19,16 +19,20 @@ using mindspore::schema::PrimitiveType_Call; namespace mindspore { namespace lite { OpParameter *PopulateCallParameter(const void *prim) { - OpParameter *call_parameter = reinterpret_cast(malloc(sizeof(OpParameter))); - if (call_parameter == nullptr) { + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + + auto *param = reinterpret_cast(malloc(sizeof(OpParameter))); + if (param == nullptr) { MS_LOG(ERROR) << "malloc CallParameter failed."; return nullptr; } - memset(call_parameter, 0, sizeof(OpParameter)); - auto primitive = static_cast(prim); - call_parameter->type_ = primitive->value_type(); - return reinterpret_cast(call_parameter); + memset(param, 0, sizeof(OpParameter)); + + param->type_ = primitive->value_type(); + return reinterpret_cast(param); } + REG_POPULATE(PrimitiveType_Call, PopulateCallParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/cast_populate.cc b/mindspore/lite/src/ops/populate/cast_populate.cc index 700b0a808e..67157c247b 100644 --- a/mindspore/lite/src/ops/populate/cast_populate.cc +++ b/mindspore/lite/src/ops/populate/cast_populate.cc @@ -18,20 +18,20 @@ using mindspore::schema::PrimitiveType_Cast; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateCastParameter(const void *prim) { + auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + auto *cast_param = reinterpret_cast(malloc(sizeof(OpParameter))); if (cast_param == nullptr) { MS_LOG(ERROR) << "malloc CastParameter failed."; return nullptr; } memset(cast_param, 0, sizeof(OpParameter)); - auto *primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); + cast_param->type_ = primitive->value_type(); return reinterpret_cast(cast_param); } -} // namespace REG_POPULATE(PrimitiveType_Cast, PopulateCastParameter, SCHEMA_CUR) } // namespace lite diff --git a/mindspore/lite/src/ops/populate/clip_populate.cc b/mindspore/lite/src/ops/populate/clip_populate.cc index fba98b4543..282a8abdfc 100644 --- a/mindspore/lite/src/ops/populate/clip_populate.cc +++ b/mindspore/lite/src/ops/populate/clip_populate.cc @@ -18,20 +18,20 @@ using mindspore::schema::PrimitiveType_Clip; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateClipParameter(const void *prim) { - auto *act_param = reinterpret_cast(malloc(sizeof(OpParameter))); - if (act_param == nullptr) { + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + + auto *param = reinterpret_cast(malloc(sizeof(OpParameter))); + if (param == nullptr) { MS_LOG(ERROR) << "malloc ClipParameter failed."; return nullptr; } - memset(act_param, 0, sizeof(OpParameter)); - auto primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); - act_param->type_ = primitive->value_type(); - return reinterpret_cast(act_param); + memset(param, 0, sizeof(OpParameter)); + + param->type_ = primitive->value_type(); + return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_Clip, PopulateClipParameter, SCHEMA_CUR) } // namespace lite diff --git a/mindspore/lite/src/ops/populate/common_populate.cc b/mindspore/lite/src/ops/populate/common_populate.cc index 47c36caeb2..35b7c3c0a1 100644 --- a/mindspore/lite/src/ops/populate/common_populate.cc +++ b/mindspore/lite/src/ops/populate/common_populate.cc @@ -19,20 +19,20 @@ using mindspore::schema::PrimitiveType_ZerosLike; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateCommonParameter(const void *prim) { - auto *common_parameter = reinterpret_cast(malloc(sizeof(OpParameter))); - if (common_parameter == nullptr) { + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + + auto *param = reinterpret_cast(malloc(sizeof(OpParameter))); + if (param == nullptr) { MS_LOG(ERROR) << "malloc OpParameter failed."; return nullptr; } - memset(common_parameter, 0, sizeof(OpParameter)); - auto primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); - common_parameter->type_ = primitive->value_type(); - return common_parameter; + memset(param, 0, sizeof(OpParameter)); + + param->type_ = primitive->value_type(); + return param; } -} // namespace REG_POPULATE(PrimitiveType_ZerosLike, PopulateCommonParameter, SCHEMA_CUR) REG_POPULATE(PrimitiveType_Depend, PopulateCommonParameter, SCHEMA_CUR) diff --git a/mindspore/lite/src/ops/populate/concat_populate.cc b/mindspore/lite/src/ops/populate/concat_populate.cc index eb30eaa078..c4a5bf48e7 100644 --- a/mindspore/lite/src/ops/populate/concat_populate.cc +++ b/mindspore/lite/src/ops/populate/concat_populate.cc @@ -19,26 +19,26 @@ using mindspore::schema::PrimitiveType_Concat; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateConcatParameter(const void *prim) { - auto *concat_param = reinterpret_cast(malloc(sizeof(ConcatParameter))); - if (concat_param == nullptr) { - MS_LOG(ERROR) << "malloc ConcatParameter failed."; - return nullptr; - } - memset(concat_param, 0, sizeof(ConcatParameter)); auto *primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - concat_param->op_parameter_.type_ = primitive->value_type(); - auto param = primitive->value_as_Concat(); - if (param == nullptr) { + auto value = primitive->value_as_Concat(); + if (value == nullptr) { MS_LOG(ERROR) << "param is nullptr"; return nullptr; } - concat_param->axis_ = static_cast(param->axis()); - return reinterpret_cast(concat_param); + + auto *param = reinterpret_cast(malloc(sizeof(ConcatParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc ConcatParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(ConcatParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->axis_ = static_cast(value->axis()); + return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_Concat, PopulateConcatParameter, SCHEMA_CUR) } // namespace lite diff --git a/mindspore/lite/src/ops/populate/constant_of_shape_populate.cc b/mindspore/lite/src/ops/populate/constant_of_shape_populate.cc index a6cda684ab..f2cabb682e 100644 --- a/mindspore/lite/src/ops/populate/constant_of_shape_populate.cc +++ b/mindspore/lite/src/ops/populate/constant_of_shape_populate.cc @@ -17,39 +17,42 @@ #include "nnacl/constant_of_shape_parameter.h" using mindspore::schema::PrimitiveType_ConstantOfShape; -namespace mindspore::lite { -namespace { +namespace mindspore { +namespace lite { OpParameter *PopulateConstantOfShapeParameter(const void *prim) { + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + auto value = primitive->value_as_ConstantOfShape(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } + auto *param = reinterpret_cast(malloc(sizeof(ConstantOfShapeParameter))); if (param == nullptr) { MS_LOG(ERROR) << "malloc ConstantOfShapeParameter failed."; return nullptr; } memset(param, 0, sizeof(ConstantOfShapeParameter)); - auto primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); + param->op_parameter_.type_ = primitive->value_type(); - auto attr = primitive->value_as_ConstantOfShape(); - if (attr == nullptr) { - MS_LOG(ERROR) << "attr is nullptr"; - return nullptr; - } - auto val = attr->value(); - if (val == nullptr) { + auto prim_val = value->value(); + if (prim_val == nullptr) { MS_LOG(ERROR) << "val is nullptr"; + free(param); return nullptr; } - auto value = std::vector(val->begin(), val->end()); - param->data_type_ = static_cast(attr->data_type()); - if (value.empty() || value.size() > 1) { + auto val = std::vector(prim_val->begin(), prim_val->end()); + param->data_type_ = static_cast(value->data_type()); + if (val.empty() || val.size() > 1) { MS_LOG(ERROR) << "The value of constant of shape is empty or more than 1."; } else { switch (param->data_type_) { case kNumberTypeFloat32: - param->value_.f32_value_ = *(val->begin()); + param->value_.f32_value_ = *(prim_val->begin()); break; case kNumberTypeInt32: - param->value_.int32_value_ = *(val->begin()); + param->value_.int32_value_ = *(prim_val->begin()); break; default: MS_LOG(ERROR) << "The value of constant of shape is invalid"; @@ -57,6 +60,7 @@ OpParameter *PopulateConstantOfShapeParameter(const void *prim) { } return reinterpret_cast(param); } -} // namespace + REG_POPULATE(PrimitiveType_ConstantOfShape, PopulateConstantOfShapeParameter, SCHEMA_CUR); -} // namespace mindspore::lite +} // namespace lite +} // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/conv2d_populate.cc b/mindspore/lite/src/ops/populate/conv2d_populate.cc index edb9b54531..4abf37314f 100644 --- a/mindspore/lite/src/ops/populate/conv2d_populate.cc +++ b/mindspore/lite/src/ops/populate/conv2d_populate.cc @@ -20,74 +20,76 @@ using mindspore::schema::PrimitiveType_Conv2DFusion; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateConvParameter(const void *prim) { - auto *conv_param = reinterpret_cast(malloc(sizeof(ConvParameter))); - if (conv_param == nullptr) { - MS_LOG(ERROR) << "malloc ConvParameter failed."; - return nullptr; - } - memset(conv_param, 0, sizeof(ConvParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - conv_param->op_parameter_.type_ = primitive->value_type(); - auto conv_primitive = primitive->value_as_Conv2DFusion(); - if (conv_primitive == nullptr) { - MS_LOG(ERROR) << "conv_primitive is nullptr"; + auto value = primitive->value_as_Conv2DFusion(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - auto kernel_size = conv_primitive->kernel_size(); - auto stride = conv_primitive->stride(); - auto pad_list = conv_primitive->pad_list(); - auto dilation = conv_primitive->dilation(); + + auto *param = reinterpret_cast(malloc(sizeof(ConvParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc ConvParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(ConvParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + auto kernel_size = value->kernel_size(); + auto stride = value->stride(); + auto pad_list = value->pad_list(); + auto dilation = value->dilation(); if (kernel_size == nullptr || stride == nullptr || dilation == nullptr) { MS_LOG(ERROR) << "nullptr"; + free(param); return nullptr; } - conv_param->kernel_h_ = static_cast(*(kernel_size->begin())); - conv_param->kernel_w_ = static_cast(*(kernel_size->begin() + 1)); - conv_param->group_ = static_cast(conv_primitive->group()); - conv_param->stride_h_ = static_cast(*(stride->begin())); - conv_param->stride_w_ = static_cast(*(stride->begin() + 1)); - switch (conv_primitive->pad_mode()) { + param->kernel_h_ = static_cast(*(kernel_size->begin())); + param->kernel_w_ = static_cast(*(kernel_size->begin() + 1)); + param->group_ = static_cast(value->group()); + param->stride_h_ = static_cast(*(stride->begin())); + param->stride_w_ = static_cast(*(stride->begin() + 1)); + switch (value->pad_mode()) { case schema::PadMode_SAME: - conv_param->pad_mode_ = Pad_same; + param->pad_mode_ = Pad_same; break; case schema::PadMode_VALID: - conv_param->pad_mode_ = Pad_valid; + param->pad_mode_ = Pad_valid; break; default: - conv_param->pad_mode_ = Pad_pad; + param->pad_mode_ = Pad_pad; } if (pad_list == nullptr || pad_list->size() < 4) { - conv_param->pad_u_ = 0; - conv_param->pad_d_ = 0; - conv_param->pad_l_ = 0; - conv_param->pad_r_ = 0; + param->pad_u_ = 0; + param->pad_d_ = 0; + param->pad_l_ = 0; + param->pad_r_ = 0; } else { - conv_param->pad_u_ = static_cast(*(pad_list->begin())); - conv_param->pad_d_ = static_cast(*(pad_list->begin() + 1)); - conv_param->pad_l_ = static_cast(*(pad_list->begin() + 2)); - conv_param->pad_r_ = static_cast(*(pad_list->begin() + 3)); + param->pad_u_ = static_cast(*(pad_list->begin())); + param->pad_d_ = static_cast(*(pad_list->begin() + 1)); + param->pad_l_ = static_cast(*(pad_list->begin() + 2)); + param->pad_r_ = static_cast(*(pad_list->begin() + 3)); } - conv_param->dilation_h_ = static_cast(*(dilation->begin())); - conv_param->dilation_w_ = static_cast(*(dilation->begin() + 1)); - conv_param->input_channel_ = static_cast(conv_primitive->in_channel()); - conv_param->output_channel_ = static_cast(conv_primitive->out_channel()); - auto act_type = conv_primitive->activation_type(); + param->dilation_h_ = static_cast(*(dilation->begin())); + param->dilation_w_ = static_cast(*(dilation->begin() + 1)); + param->input_channel_ = static_cast(value->in_channel()); + param->output_channel_ = static_cast(value->out_channel()); + auto act_type = value->activation_type(); switch (act_type) { case schema::ActivationType_RELU: - conv_param->act_type_ = ActType_Relu; + param->act_type_ = ActType_Relu; break; case schema::ActivationType_RELU6: - conv_param->act_type_ = ActType_Relu6; + param->act_type_ = ActType_Relu6; break; default: - conv_param->act_type_ = ActType_No; + param->act_type_ = ActType_No; } - return reinterpret_cast(conv_param); + return reinterpret_cast(param); } -} // namespace + REG_POPULATE(PrimitiveType_Conv2DFusion, PopulateConvParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/crop_and_resize_populate.cc b/mindspore/lite/src/ops/populate/crop_and_resize_populate.cc index 3c35dea395..19a9689057 100644 --- a/mindspore/lite/src/ops/populate/crop_and_resize_populate.cc +++ b/mindspore/lite/src/ops/populate/crop_and_resize_populate.cc @@ -16,29 +16,30 @@ #include "src/ops/populate/populate_register.h" #include "nnacl/resize_parameter.h" using mindspore::schema::PrimitiveType_CropAndResize; + namespace mindspore { namespace lite { -namespace { OpParameter *PopulateCropAndResizeParameter(const void *prim) { - auto *crop_resize_param = reinterpret_cast(malloc(sizeof(CropAndResizeParameter))); - if (crop_resize_param == nullptr) { - MS_LOG(ERROR) << "malloc CropAndResizeParameter failed."; - return nullptr; - } - memset(crop_resize_param, 0, sizeof(CropAndResizeParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - crop_resize_param->op_parameter_.type_ = primitive->value_type(); - auto param = primitive->value_as_CropAndResize(); + auto value = primitive->value_as_CropAndResize(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } + + auto *param = reinterpret_cast(malloc(sizeof(CropAndResizeParameter))); if (param == nullptr) { - MS_LOG(ERROR) << "param is nullptr"; + MS_LOG(ERROR) << "malloc CropAndResizeParameter failed."; return nullptr; } - crop_resize_param->method_ = static_cast(param->method()); - crop_resize_param->extrapolation_value_ = param->extrapolation_value(); - return reinterpret_cast(crop_resize_param); + memset(param, 0, sizeof(CropAndResizeParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->method_ = static_cast(value->method()); + param->extrapolation_value_ = value->extrapolation_value(); + return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_CropAndResize, PopulateCropAndResizeParameter, SCHEMA_CUR); } // namespace lite diff --git a/mindspore/lite/src/ops/populate/crop_populate.cc b/mindspore/lite/src/ops/populate/crop_populate.cc index f14258821e..94edf794c9 100644 --- a/mindspore/lite/src/ops/populate/crop_populate.cc +++ b/mindspore/lite/src/ops/populate/crop_populate.cc @@ -19,39 +19,42 @@ using mindspore::schema::PrimitiveType_Crop; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateCropParameter(const void *prim) { auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - auto crop_prim = primitive->value_as_Crop(); - if (crop_prim == nullptr) { - MS_LOG(ERROR) << "crop_prim is nullptr"; + auto value = primitive->value_as_Crop(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - auto param_offset = crop_prim->offsets(); + + auto *param = reinterpret_cast(malloc(sizeof(CropParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc CropParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(CropParameter)); + + auto param_offset = value->offsets(); if (param_offset == nullptr) { MS_LOG(ERROR) << "param_offset is nullptr"; + free(param); return nullptr; } if (param_offset->size() > COMM_SHAPE_SIZE) { - MS_LOG(ERROR) << "crop_param offset size(" << param_offset->size() << ") should <= " << COMM_SHAPE_SIZE; + MS_LOG(ERROR) << "param offset size(" << param_offset->size() << ") should <= " << COMM_SHAPE_SIZE; + free(param); return nullptr; } - auto *crop_param = reinterpret_cast(malloc(sizeof(CropParameter))); - if (crop_param == nullptr) { - MS_LOG(ERROR) << "malloc CropParameter failed."; - return nullptr; - } - memset(crop_param, 0, sizeof(CropParameter)); - crop_param->op_parameter_.type_ = primitive->value_type(); - crop_param->axis_ = crop_prim->axis(); - crop_param->offset_size_ = param_offset->size(); + + param->op_parameter_.type_ = primitive->value_type(); + param->axis_ = value->axis(); + param->offset_size_ = param_offset->size(); for (size_t i = 0; i < param_offset->size(); ++i) { - crop_param->offset_[i] = *(param_offset->begin() + i); + param->offset_[i] = *(param_offset->begin() + i); } - return reinterpret_cast(crop_param); + return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_Crop, PopulateCropParameter, SCHEMA_CUR) } // namespace lite diff --git a/mindspore/lite/src/ops/populate/cumsum_populate.cc b/mindspore/lite/src/ops/populate/cumsum_populate.cc index b5a925829f..515eceb86b 100644 --- a/mindspore/lite/src/ops/populate/cumsum_populate.cc +++ b/mindspore/lite/src/ops/populate/cumsum_populate.cc @@ -19,22 +19,27 @@ using mindspore::schema::PrimitiveType_CumSum; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateCumSumParameter(const void *prim) { auto primitive = static_cast(prim); - auto cumsum_prim = primitive->value_as_CumSum(); - CumSumParameter *cumsum_param = reinterpret_cast(malloc(sizeof(CumSumParameter))); - if (cumsum_param == nullptr) { + MS_ASSERT(primitive != nullptr); + auto value = primitive->value_as_CumSum(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } + + auto *param = reinterpret_cast(malloc(sizeof(CumSumParameter))); + if (param == nullptr) { MS_LOG(ERROR) << "malloc CumsumParameter failed."; return nullptr; } - memset(cumsum_param, 0, sizeof(CumSumParameter)); - cumsum_param->op_parameter_.type_ = primitive->value_type(); - cumsum_param->exclusive_ = cumsum_prim->exclusive(); - cumsum_param->reverse_ = cumsum_prim->reverse(); - return reinterpret_cast(cumsum_param); + memset(param, 0, sizeof(CumSumParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->exclusive_ = value->exclusive(); + param->reverse_ = value->reverse(); + return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_CumSum, PopulateCumSumParameter, SCHEMA_CUR) } // namespace lite diff --git a/mindspore/lite/src/ops/populate/custom_extract_features_populate.cc b/mindspore/lite/src/ops/populate/custom_extract_features_populate.cc index 91ecc51594..b6ac687730 100644 --- a/mindspore/lite/src/ops/populate/custom_extract_features_populate.cc +++ b/mindspore/lite/src/ops/populate/custom_extract_features_populate.cc @@ -18,20 +18,21 @@ using mindspore::schema::PrimitiveType_CustomExtractFeatures; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateExtractFeaturesParameter(const void *prim) { + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + auto *param = reinterpret_cast(malloc(sizeof(OpParameter))); if (param == nullptr) { MS_LOG(ERROR) << "new OpParameter failed."; return nullptr; } memset(param, 0, sizeof(OpParameter)); - auto primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); + param->type_ = primitive->value_type(); - return param; + return reinterpret_cast(param); } -} // namespace + REG_POPULATE(PrimitiveType_CustomExtractFeatures, PopulateExtractFeaturesParameter, SCHEMA_CUR); } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/custom_normalize_populate.cc b/mindspore/lite/src/ops/populate/custom_normalize_populate.cc index dc85451008..9a7e04c6db 100644 --- a/mindspore/lite/src/ops/populate/custom_normalize_populate.cc +++ b/mindspore/lite/src/ops/populate/custom_normalize_populate.cc @@ -19,17 +19,20 @@ using mindspore::schema::PrimitiveType_CustomNormalize; namespace mindspore { namespace lite { OpParameter *PopulateCustomNormalizeParameter(const void *prim) { + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + auto *param = reinterpret_cast(malloc(sizeof(OpParameter))); if (param == nullptr) { MS_LOG(ERROR) << "new OpParameter failed."; return nullptr; } memset(param, 0, sizeof(OpParameter)); - auto primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); + param->type_ = primitive->value_type(); - return param; + return reinterpret_cast(param); } + REG_POPULATE(PrimitiveType_CustomNormalize, PopulateCustomNormalizeParameter, SCHEMA_CUR); } // namespace lite diff --git a/mindspore/lite/src/ops/populate/custom_predict_populate.cc b/mindspore/lite/src/ops/populate/custom_predict_populate.cc index 17e693868c..0c71568b11 100644 --- a/mindspore/lite/src/ops/populate/custom_predict_populate.cc +++ b/mindspore/lite/src/ops/populate/custom_predict_populate.cc @@ -20,12 +20,6 @@ using mindspore::schema::PrimitiveType_CustomPredict; namespace mindspore { namespace lite { OpParameter *PopulateCustomPredictParameter(const void *prim) { - PredictParameter *param = reinterpret_cast(malloc(sizeof(PredictParameter))); - if (param == nullptr) { - MS_LOG(ERROR) << "malloc param failed."; - return nullptr; - } - memset(param, 0, sizeof(PredictParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_CustomPredict(); @@ -33,12 +27,20 @@ OpParameter *PopulateCustomPredictParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } + + auto *param = reinterpret_cast(malloc(sizeof(PredictParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc param failed."; + return nullptr; + } + memset(param, 0, sizeof(PredictParameter)); + param->op_parameter_.type_ = primitive->value_type(); param->output_num = value->output_num(); param->weight_threshold = value->weight_threshold(); return reinterpret_cast(param); } -REG_POPULATE(PrimitiveType_CustomPredict, PopulateCustomPredictParameter, SCHEMA_CUR); +REG_POPULATE(PrimitiveType_CustomPredict, PopulateCustomPredictParameter, SCHEMA_CUR); } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/deconv2d_populate.cc b/mindspore/lite/src/ops/populate/deconv2d_populate.cc index dc82232427..b5403442ed 100644 --- a/mindspore/lite/src/ops/populate/deconv2d_populate.cc +++ b/mindspore/lite/src/ops/populate/deconv2d_populate.cc @@ -21,74 +21,77 @@ using mindspore::schema::PrimitiveType_Conv2dTransposeFusion; namespace mindspore { namespace lite { OpParameter *PopulateDeconvParameter(const void *prim) { - auto *conv_param = reinterpret_cast(malloc(sizeof(ConvParameter))); - if (conv_param == nullptr) { - MS_LOG(ERROR) << "malloc ConvParameter failed."; - return nullptr; - } - memset(conv_param, 0, sizeof(ConvParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - conv_param->op_parameter_.type_ = primitive->value_type(); - auto conv_primitive = primitive->value_as_Conv2dTransposeFusion(); - if (conv_primitive == nullptr) { - MS_LOG(ERROR) << "conv_primitive is nullptr"; + auto value = primitive->value_as_Conv2dTransposeFusion(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } + + auto *param = reinterpret_cast(malloc(sizeof(ConvParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc ConvParameter failed."; return nullptr; } - auto kernel_size = conv_primitive->kernel_size(); - auto stride = conv_primitive->stride(); - auto pad_list = conv_primitive->pad_list(); - auto dilation = conv_primitive->dilation(); - auto output_paddings = conv_primitive->output_paddings(); + memset(param, 0, sizeof(ConvParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + auto kernel_size = value->kernel_size(); + auto stride = value->stride(); + auto pad_list = value->pad_list(); + auto dilation = value->dilation(); + auto output_paddings = value->output_paddings(); if (kernel_size == nullptr || stride == nullptr || dilation == nullptr || output_paddings == nullptr) { MS_LOG(ERROR) << "nullptr"; + free(param); return nullptr; } - conv_param->kernel_h_ = static_cast(*(kernel_size->begin())); - conv_param->kernel_w_ = static_cast(*(kernel_size->begin() + 1)); - conv_param->group_ = static_cast(conv_primitive->group()); - conv_param->stride_h_ = static_cast(*(stride->begin())); - conv_param->stride_w_ = static_cast(*(stride->begin() + 1)); - conv_param->output_padding_h_ = static_cast(*(output_paddings->begin())); - conv_param->output_padding_w_ = static_cast(*(output_paddings->begin() + 1)); - switch (conv_primitive->pad_mode()) { + param->kernel_h_ = static_cast(*(kernel_size->begin())); + param->kernel_w_ = static_cast(*(kernel_size->begin() + 1)); + param->group_ = static_cast(value->group()); + param->stride_h_ = static_cast(*(stride->begin())); + param->stride_w_ = static_cast(*(stride->begin() + 1)); + param->output_padding_h_ = static_cast(*(output_paddings->begin())); + param->output_padding_w_ = static_cast(*(output_paddings->begin() + 1)); + switch (value->pad_mode()) { case schema::PadMode_SAME: - conv_param->pad_mode_ = Pad_same; + param->pad_mode_ = Pad_same; break; case schema::PadMode_VALID: - conv_param->pad_mode_ = Pad_valid; + param->pad_mode_ = Pad_valid; break; default: - conv_param->pad_mode_ = Pad_pad; + param->pad_mode_ = Pad_pad; } if (pad_list == nullptr || pad_list->size() < 4) { - conv_param->pad_u_ = 0; - conv_param->pad_d_ = 0; - conv_param->pad_l_ = 0; - conv_param->pad_r_ = 0; + param->pad_u_ = 0; + param->pad_d_ = 0; + param->pad_l_ = 0; + param->pad_r_ = 0; } else { - conv_param->pad_u_ = static_cast(*(pad_list->begin())); - conv_param->pad_d_ = static_cast(*(pad_list->begin() + 1)); - conv_param->pad_l_ = static_cast(*(pad_list->begin() + 2)); - conv_param->pad_r_ = static_cast(*(pad_list->begin() + 3)); + param->pad_u_ = static_cast(*(pad_list->begin())); + param->pad_d_ = static_cast(*(pad_list->begin() + 1)); + param->pad_l_ = static_cast(*(pad_list->begin() + 2)); + param->pad_r_ = static_cast(*(pad_list->begin() + 3)); } - conv_param->dilation_h_ = static_cast(*(dilation->begin())); - conv_param->dilation_w_ = static_cast(*(dilation->begin() + 1)); - conv_param->input_channel_ = static_cast(conv_primitive->in_channel()); - conv_param->output_channel_ = static_cast(conv_primitive->out_channel()); - auto act_type = conv_primitive->activation_type(); + param->dilation_h_ = static_cast(*(dilation->begin())); + param->dilation_w_ = static_cast(*(dilation->begin() + 1)); + param->input_channel_ = static_cast(value->in_channel()); + param->output_channel_ = static_cast(value->out_channel()); + auto act_type = value->activation_type(); switch (act_type) { case schema::ActivationType_RELU: - conv_param->act_type_ = ActType_Relu; + param->act_type_ = ActType_Relu; break; case schema::ActivationType_RELU6: - conv_param->act_type_ = ActType_Relu6; + param->act_type_ = ActType_Relu6; break; default: - conv_param->act_type_ = ActType_No; + param->act_type_ = ActType_No; break; } - return reinterpret_cast(conv_param); + return reinterpret_cast(param); } REG_POPULATE(PrimitiveType_Conv2dTransposeFusion, PopulateDeconvParameter, SCHEMA_CUR) diff --git a/mindspore/lite/src/ops/populate/default_populate.cc b/mindspore/lite/src/ops/populate/default_populate.cc index 6e30c41b30..36c7aa4e9c 100644 --- a/mindspore/lite/src/ops/populate/default_populate.cc +++ b/mindspore/lite/src/ops/populate/default_populate.cc @@ -22,14 +22,16 @@ namespace mindspore { namespace lite { OpParameter *DefaultPopulateParameter(const void *prim) { + auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + auto *param = static_cast(malloc(sizeof(OpParameter))); if (param == nullptr) { MS_LOG(ERROR) << "Malloc OpParameter failed."; return nullptr; } memset(param, 0, sizeof(OpParameter)); - auto *primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); + param->type_ = primitive->value_type(); return param; } diff --git a/mindspore/lite/src/ops/populate/depth_to_space_populate.cc b/mindspore/lite/src/ops/populate/depth_to_space_populate.cc index 144a2fe746..c20d624926 100644 --- a/mindspore/lite/src/ops/populate/depth_to_space_populate.cc +++ b/mindspore/lite/src/ops/populate/depth_to_space_populate.cc @@ -21,22 +21,24 @@ namespace mindspore { namespace lite { namespace { OpParameter *PopulateDepthToSpaceParameter(const void *prim) { - auto *depth_space_param = reinterpret_cast(malloc(sizeof(DepthToSpaceParameter))); - if (depth_space_param == nullptr) { - MS_LOG(ERROR) << "malloc DepthToSpaceParameter failed."; - return nullptr; - } - memset(depth_space_param, 0, sizeof(DepthToSpaceParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - auto param = primitive->value_as_DepthToSpace(); + auto value = primitive->value_as_DepthToSpace(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } + + auto *param = reinterpret_cast(malloc(sizeof(DepthToSpaceParameter))); if (param == nullptr) { - MS_LOG(ERROR) << "param is nullptr"; + MS_LOG(ERROR) << "malloc DepthToSpaceParameter failed."; return nullptr; } - depth_space_param->op_parameter_.type_ = primitive->value_type(); - depth_space_param->block_size_ = param->block_size(); - return reinterpret_cast(depth_space_param); + memset(param, 0, sizeof(DepthToSpaceParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->block_size_ = value->block_size(); + return reinterpret_cast(param); } } // namespace diff --git a/mindspore/lite/src/ops/populate/depthwise_conv2d_populate.cc b/mindspore/lite/src/ops/populate/depthwise_conv2d_populate.cc index 21be649792..591eeadb32 100644 --- a/mindspore/lite/src/ops/populate/depthwise_conv2d_populate.cc +++ b/mindspore/lite/src/ops/populate/depthwise_conv2d_populate.cc @@ -19,13 +19,14 @@ namespace mindspore { namespace lite { OpParameter *PopulateConvDwParameter(const void *primitive) { - auto *conv_param = reinterpret_cast(malloc(sizeof(ConvParameter))); - if (conv_param == nullptr) { + auto *param = reinterpret_cast(malloc(sizeof(ConvParameter))); + if (param == nullptr) { MS_LOG(ERROR) << "malloc ConvParameter failed."; return nullptr; } - memset(conv_param, 0, sizeof(ConvParameter)); - return reinterpret_cast(conv_param); + memset(param, 0, sizeof(ConvParameter)); + + return reinterpret_cast(param); } } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/detection_post_process_populate.cc b/mindspore/lite/src/ops/populate/detection_post_process_populate.cc index 20ad515018..ac421abbd4 100644 --- a/mindspore/lite/src/ops/populate/detection_post_process_populate.cc +++ b/mindspore/lite/src/ops/populate/detection_post_process_populate.cc @@ -19,43 +19,43 @@ using mindspore::schema::PrimitiveType_DetectionPostProcess; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateDetectionPostProcessParameter(const void *prim) { - auto *detection_post_process_parameter = - reinterpret_cast(malloc(sizeof(DetectionPostProcessParameter))); - if (detection_post_process_parameter == nullptr) { - MS_LOG(ERROR) << "malloc EluParameter failed."; - return nullptr; - } - memset(detection_post_process_parameter, 0, sizeof(DetectionPostProcessParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - detection_post_process_parameter->op_parameter_.type_ = primitive->value_type(); - auto param = primitive->value_as_DetectionPostProcess(); + auto value = primitive->value_as_DetectionPostProcess(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } + + auto *param = reinterpret_cast(malloc(sizeof(DetectionPostProcessParameter))); if (param == nullptr) { - MS_LOG(ERROR) << "param is nullptr"; + MS_LOG(ERROR) << "malloc DetectionPostProcessParameter failed."; return nullptr; } - auto scale = param->scale(); + memset(param, 0, sizeof(DetectionPostProcessParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + auto scale = value->scale(); if (scale == nullptr) { MS_LOG(ERROR) << "scale is nullptr"; + free(param); return nullptr; } - detection_post_process_parameter->h_scale_ = *(scale->begin()); - detection_post_process_parameter->w_scale_ = *(scale->begin() + 1); - detection_post_process_parameter->x_scale_ = *(scale->begin() + 2); - detection_post_process_parameter->y_scale_ = *(scale->begin() + 3); - detection_post_process_parameter->nms_iou_threshold_ = param->nms_iou_threshold(); - detection_post_process_parameter->nms_score_threshold_ = param->nms_score_threshold(); - detection_post_process_parameter->max_detections_ = param->max_detections(); - detection_post_process_parameter->detections_per_class_ = param->detections_per_class(); - detection_post_process_parameter->max_classes_per_detection_ = param->max_classes_per_detection(); - detection_post_process_parameter->num_classes_ = param->num_classes(); - detection_post_process_parameter->use_regular_nms_ = param->use_regular_nms(); - return reinterpret_cast(detection_post_process_parameter); + param->h_scale_ = *(scale->begin()); + param->w_scale_ = *(scale->begin() + 1); + param->x_scale_ = *(scale->begin() + 2); + param->y_scale_ = *(scale->begin() + 3); + param->nms_iou_threshold_ = value->nms_iou_threshold(); + param->nms_score_threshold_ = value->nms_score_threshold(); + param->max_detections_ = value->max_detections(); + param->detections_per_class_ = value->detections_per_class(); + param->max_classes_per_detection_ = value->max_classes_per_detection(); + param->num_classes_ = value->num_classes(); + param->use_regular_nms_ = value->use_regular_nms(); + return reinterpret_cast(param); } -} // namespace -REG_POPULATE(PrimitiveType_DetectionPostProcess, PopulateDetectionPostProcessParameter, SCHEMA_CUR); +REG_POPULATE(PrimitiveType_DetectionPostProcess, PopulateDetectionPostProcessParameter, SCHEMA_CUR); } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/div_populate.cc b/mindspore/lite/src/ops/populate/div_populate.cc index fef701b4f8..e2f63312df 100644 --- a/mindspore/lite/src/ops/populate/div_populate.cc +++ b/mindspore/lite/src/ops/populate/div_populate.cc @@ -21,9 +21,10 @@ namespace lite { OpParameter *PopulateDivParameter(const void *prim) { auto *param = PopulateArithmeticCommonPara(prim); if (param == nullptr) { - MS_LOG(ERROR) << "PopulateArithmeticCommonPara failed."; + MS_LOG(ERROR) << "get PopulateArithmeticCommonPara failed."; return nullptr; } + return reinterpret_cast(param); } diff --git a/mindspore/lite/src/ops/populate/eltwise_populate.cc b/mindspore/lite/src/ops/populate/eltwise_populate.cc index c416bc1c22..9536f65e5c 100644 --- a/mindspore/lite/src/ops/populate/eltwise_populate.cc +++ b/mindspore/lite/src/ops/populate/eltwise_populate.cc @@ -19,24 +19,24 @@ using mindspore::schema::PrimitiveType_Eltwise; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateEltwiseParameter(const void *prim) { + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + auto value = primitive->value_as_Eltwise(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } + ArithmeticParameter *param = PopulateArithmeticCommonPara(prim); if (param == nullptr) { MS_LOG(ERROR) << "PopulateArithmeticCommonPara failed."; return nullptr; } - auto primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); - auto eltwise_param = primitive->value_as_Eltwise(); - if (eltwise_param == nullptr) { - MS_LOG(ERROR) << "eltwise_param is nullptr"; - return nullptr; - } - param->eltwise_mode_ = eltwise_param->mode(); + + param->eltwise_mode_ = value->mode(); return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_Eltwise, PopulateEltwiseParameter, SCHEMA_CUR) } // namespace lite diff --git a/mindspore/lite/src/ops/populate/elu_populate.cc b/mindspore/lite/src/ops/populate/elu_populate.cc index 897da96e28..7ad591d48b 100644 --- a/mindspore/lite/src/ops/populate/elu_populate.cc +++ b/mindspore/lite/src/ops/populate/elu_populate.cc @@ -19,26 +19,27 @@ using mindspore::schema::PrimitiveType_Elu; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateEluParameter(const void *prim) { - auto *elu_parameter = reinterpret_cast(malloc(sizeof(EluParameter))); - if (elu_parameter == nullptr) { - MS_LOG(ERROR) << "malloc EluParameter failed."; - return nullptr; - } - memset(elu_parameter, 0, sizeof(EluParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - elu_parameter->op_parameter_.type_ = primitive->value_type(); - auto param = primitive->value_as_Elu(); + auto value = primitive->value_as_Elu(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } + + auto *param = reinterpret_cast(malloc(sizeof(EluParameter))); if (param == nullptr) { - MS_LOG(ERROR) << "param is nullptr"; + MS_LOG(ERROR) << "malloc EluParameter failed."; return nullptr; } - elu_parameter->alpha_ = param->alpha(); - return reinterpret_cast(elu_parameter); + memset(param, 0, sizeof(EluParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->alpha_ = value->alpha(); + return reinterpret_cast(param); } -} // namespace + REG_POPULATE(PrimitiveType_Elu, PopulateEluParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/embedding_lookup_populate.cc b/mindspore/lite/src/ops/populate/embedding_lookup_populate.cc index 920d00bd52..89bceff5a4 100644 --- a/mindspore/lite/src/ops/populate/embedding_lookup_populate.cc +++ b/mindspore/lite/src/ops/populate/embedding_lookup_populate.cc @@ -19,15 +19,7 @@ using mindspore::schema::PrimitiveType_EmbeddingLookupFusion; namespace mindspore { namespace lite { - OpParameter *PopulateEmbeddingLookupParameter(const void *prim) { - auto *param = reinterpret_cast(malloc(sizeof(EmbeddingLookupParameter))); - if (param == nullptr) { - MS_LOG(ERROR) << "malloc EmbeddingLookupParameter failed."; - return nullptr; - } - memset(param, 0, sizeof(EmbeddingLookupParameter)); - auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_EmbeddingLookupFusion(); @@ -35,6 +27,14 @@ OpParameter *PopulateEmbeddingLookupParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } + + auto *param = reinterpret_cast(malloc(sizeof(EmbeddingLookupParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc EmbeddingLookupParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(EmbeddingLookupParameter)); + param->op_parameter_.type_ = primitive->value_type(); param->max_norm_ = value->max_norm(); if (param->max_norm_ < 0) { diff --git a/mindspore/lite/src/ops/populate/exp_populate.cc b/mindspore/lite/src/ops/populate/exp_populate.cc index 49d4061bbc..d0f5b28bd7 100644 --- a/mindspore/lite/src/ops/populate/exp_populate.cc +++ b/mindspore/lite/src/ops/populate/exp_populate.cc @@ -20,13 +20,6 @@ using mindspore::schema::PrimitiveType_ExpFusion; namespace mindspore { namespace lite { OpParameter *PopulateExpParameter(const void *prim) { - auto *exp_parameter = reinterpret_cast(malloc(sizeof(ExpParameter))); - if (exp_parameter == nullptr) { - MS_LOG(ERROR) << "malloc ExpParameter failed."; - return nullptr; - } - memset(exp_parameter, 0, sizeof(ExpParameter)); - auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_ExpFusion(); @@ -34,16 +27,24 @@ OpParameter *PopulateExpParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - exp_parameter->op_parameter_.type_ = primitive->value_type(); - exp_parameter->base_ = value->base(); - exp_parameter->scale_ = value->scale(); - exp_parameter->shift_ = value->shift(); - if (exp_parameter->base_ != -1 && exp_parameter->base_ <= 0) { - MS_LOG(ERROR) << "Exp base must be strictly positive, got " << exp_parameter->base_; - free(exp_parameter); + + auto *param = reinterpret_cast(malloc(sizeof(ExpParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc ExpParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(ExpParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->base_ = value->base(); + param->scale_ = value->scale(); + param->shift_ = value->shift(); + if (param->base_ != -1 && param->base_ <= 0) { + MS_LOG(ERROR) << "Exp base must be strictly positive, got " << param->base_; + free(param); return nullptr; } - return reinterpret_cast(exp_parameter); + return reinterpret_cast(param); } REG_POPULATE(PrimitiveType_ExpFusion, PopulateExpParameter, SCHEMA_CUR) diff --git a/mindspore/lite/src/ops/populate/expand_dims_populate.cc b/mindspore/lite/src/ops/populate/expand_dims_populate.cc index 75fcacd782..279f1bf14c 100644 --- a/mindspore/lite/src/ops/populate/expand_dims_populate.cc +++ b/mindspore/lite/src/ops/populate/expand_dims_populate.cc @@ -18,20 +18,20 @@ using mindspore::schema::PrimitiveType_ExpandDims; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateExpandDimsParameter(const void *prim) { - auto *expand_param = reinterpret_cast(malloc(sizeof(OpParameter))); - if (expand_param == nullptr) { + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + + auto *param = reinterpret_cast(malloc(sizeof(OpParameter))); + if (param == nullptr) { MS_LOG(ERROR) << "malloc ExpandDimsParameter failed."; return nullptr; } - memset(expand_param, 0, sizeof(OpParameter)); - auto primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); - expand_param->type_ = primitive->value_type(); - return reinterpret_cast(expand_param); + memset(param, 0, sizeof(OpParameter)); + + param->type_ = primitive->value_type(); + return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_ExpandDims, PopulateExpandDimsParameter, SCHEMA_CUR) } // namespace lite diff --git a/mindspore/lite/src/ops/populate/fill_populate.cc b/mindspore/lite/src/ops/populate/fill_populate.cc index 4742786619..a9ab2bebe0 100644 --- a/mindspore/lite/src/ops/populate/fill_populate.cc +++ b/mindspore/lite/src/ops/populate/fill_populate.cc @@ -18,20 +18,20 @@ using mindspore::schema::PrimitiveType_Fill; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateFillParameter(const void *prim) { - auto *fill_param = reinterpret_cast(malloc(sizeof(OpParameter))); - if (fill_param == nullptr) { + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + + auto *param = reinterpret_cast(malloc(sizeof(OpParameter))); + if (param == nullptr) { MS_LOG(ERROR) << "malloc FillParameter failed."; return nullptr; } - memset(fill_param, 0, sizeof(OpParameter)); - auto primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); - fill_param->type_ = primitive->value_type(); - return reinterpret_cast(fill_param); + memset(param, 0, sizeof(OpParameter)); + + param->type_ = primitive->value_type(); + return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_Fill, PopulateFillParameter, SCHEMA_CUR) } // namespace lite diff --git a/mindspore/lite/src/ops/populate/flatten_populate.cc b/mindspore/lite/src/ops/populate/flatten_populate.cc index 7cdf366074..de1acf530a 100644 --- a/mindspore/lite/src/ops/populate/flatten_populate.cc +++ b/mindspore/lite/src/ops/populate/flatten_populate.cc @@ -19,17 +19,18 @@ using mindspore::schema::PrimitiveType_Flatten; namespace mindspore { namespace lite { OpParameter *PopulateFlattenParameter(const void *prim) { - auto *flatten_param = reinterpret_cast(malloc(sizeof(OpParameter))); - if (flatten_param == nullptr) { + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + + auto *param = reinterpret_cast(malloc(sizeof(OpParameter))); + if (param == nullptr) { MS_LOG(ERROR) << "malloc FlattenParameter failed."; return nullptr; } - memset(flatten_param, 0, sizeof(OpParameter)); + memset(param, 0, sizeof(OpParameter)); - auto primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); - flatten_param->type_ = primitive->value_type(); - return reinterpret_cast(flatten_param); + param->type_ = primitive->value_type(); + return reinterpret_cast(param); } REG_POPULATE(PrimitiveType_Flatten, PopulateFlattenParameter, SCHEMA_CUR) diff --git a/mindspore/lite/src/ops/populate/full_connection_populate.cc b/mindspore/lite/src/ops/populate/full_connection_populate.cc index 2935b55063..b32a085abd 100644 --- a/mindspore/lite/src/ops/populate/full_connection_populate.cc +++ b/mindspore/lite/src/ops/populate/full_connection_populate.cc @@ -19,37 +19,37 @@ using mindspore::schema::PrimitiveType_FullConnection; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateFullconnectionParameter(const void *prim) { - auto *matmul_param = reinterpret_cast(malloc(sizeof(MatMulParameter))); - if (matmul_param == nullptr) { - MS_LOG(ERROR) << "malloc MatMulParameter failed."; - return nullptr; - } - memset(matmul_param, 0, sizeof(MatMulParameter)); auto *primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - matmul_param->op_parameter_.type_ = primitive->value_type(); - auto full_conn_prim = primitive->value_as_FullConnection(); - if (full_conn_prim == nullptr) { - MS_LOG(ERROR) << "full_conn_prim is nullptr"; + auto value = primitive->value_as_FullConnection(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } + + auto *param = reinterpret_cast(malloc(sizeof(MatMulParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc MatMulParameter failed."; return nullptr; } - matmul_param->b_transpose_ = true; - matmul_param->a_transpose_ = false; - matmul_param->has_bias_ = full_conn_prim->has_bias(); - if (full_conn_prim->activation_type() == schema::ActivationType_RELU) { - matmul_param->act_type_ = ActType_Relu; - } else if (full_conn_prim->activation_type() == schema::ActivationType_RELU6) { - matmul_param->act_type_ = ActType_Relu6; + memset(param, 0, sizeof(MatMulParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->b_transpose_ = true; + param->a_transpose_ = false; + param->has_bias_ = value->has_bias(); + if (value->activation_type() == schema::ActivationType_RELU) { + param->act_type_ = ActType_Relu; + } else if (value->activation_type() == schema::ActivationType_RELU6) { + param->act_type_ = ActType_Relu6; } else { - matmul_param->act_type_ = ActType_No; + param->act_type_ = ActType_No; } - matmul_param->axis_ = full_conn_prim->axis(); - matmul_param->use_axis_ = full_conn_prim->use_axis(); - return reinterpret_cast(matmul_param); + param->axis_ = value->axis(); + param->use_axis_ = value->use_axis(); + return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_FullConnection, PopulateFullconnectionParameter, SCHEMA_CUR) } // namespace lite diff --git a/mindspore/lite/src/ops/populate/fused_batchnorm_populate.cc b/mindspore/lite/src/ops/populate/fused_batchnorm_populate.cc index 3654ea816b..026580a37f 100644 --- a/mindspore/lite/src/ops/populate/fused_batchnorm_populate.cc +++ b/mindspore/lite/src/ops/populate/fused_batchnorm_populate.cc @@ -20,12 +20,6 @@ using mindspore::schema::PrimitiveType_FusedBatchNorm; namespace mindspore { namespace lite { OpParameter *PopulateFusedBatchNorm(const void *prim) { - auto *batch_norm_param = reinterpret_cast(malloc(sizeof(BatchNormParameter))); - if (batch_norm_param == nullptr) { - MS_LOG(ERROR) << "malloc BatchNormParameter failed."; - return nullptr; - } - memset(batch_norm_param, 0, sizeof(BatchNormParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_FusedBatchNorm(); @@ -33,11 +27,19 @@ OpParameter *PopulateFusedBatchNorm(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - batch_norm_param->op_parameter_.type_ = primitive->value_type(); - batch_norm_param->epsilon_ = value->epsilon(); - batch_norm_param->momentum_ = value->momentum(); - batch_norm_param->fused_ = true; - return reinterpret_cast(batch_norm_param); + + auto *param = reinterpret_cast(malloc(sizeof(BatchNormParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc BatchNormParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(BatchNormParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->epsilon_ = value->epsilon(); + param->momentum_ = value->momentum(); + param->fused_ = true; + return reinterpret_cast(param); } REG_POPULATE(PrimitiveType_FusedBatchNorm, PopulateFusedBatchNorm, SCHEMA_CUR) diff --git a/mindspore/lite/src/ops/populate/gather_nd_populate.cc b/mindspore/lite/src/ops/populate/gather_nd_populate.cc index 5fc5a7d886..e389f3aabb 100644 --- a/mindspore/lite/src/ops/populate/gather_nd_populate.cc +++ b/mindspore/lite/src/ops/populate/gather_nd_populate.cc @@ -19,20 +19,20 @@ using mindspore::schema::PrimitiveType_GatherNd; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateGatherNdParameter(const void *prim) { - auto *gather_nd_param = reinterpret_cast(malloc(sizeof(GatherNdParameter))); - if (gather_nd_param == nullptr) { + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + + auto *param = reinterpret_cast(malloc(sizeof(GatherNdParameter))); + if (param == nullptr) { MS_LOG(ERROR) << "malloc GatherNdParameter failed."; return nullptr; } - memset(gather_nd_param, 0, sizeof(GatherNdParameter)); - auto primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); - gather_nd_param->op_parameter_.type_ = primitive->value_type(); - return reinterpret_cast(gather_nd_param); + memset(param, 0, sizeof(GatherNdParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_GatherNd, PopulateGatherNdParameter, SCHEMA_CUR) } // namespace lite diff --git a/mindspore/lite/src/ops/populate/gather_populate.cc b/mindspore/lite/src/ops/populate/gather_populate.cc index ab454237ad..9c22a44797 100644 --- a/mindspore/lite/src/ops/populate/gather_populate.cc +++ b/mindspore/lite/src/ops/populate/gather_populate.cc @@ -19,21 +19,20 @@ using mindspore::schema::PrimitiveType_Gather; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateGatherParameter(const void *prim) { - auto *gather_param = reinterpret_cast(malloc(sizeof(GatherParameter))); - if (gather_param == nullptr) { + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + + auto *param = reinterpret_cast(malloc(sizeof(GatherParameter))); + if (param == nullptr) { MS_LOG(ERROR) << "malloc GatherParameter failed."; return nullptr; } - memset(gather_param, 0, sizeof(GatherParameter)); - auto primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); - gather_param->op_parameter_.type_ = primitive->value_type(); + memset(param, 0, sizeof(GatherParameter)); - return reinterpret_cast(gather_param); + param->op_parameter_.type_ = primitive->value_type(); + return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_Gather, PopulateGatherParameter, SCHEMA_CUR) } // namespace lite diff --git a/mindspore/lite/src/ops/populate/gru_populate.cc b/mindspore/lite/src/ops/populate/gru_populate.cc index b3a8384c2b..004bfcdffc 100644 --- a/mindspore/lite/src/ops/populate/gru_populate.cc +++ b/mindspore/lite/src/ops/populate/gru_populate.cc @@ -19,27 +19,26 @@ using mindspore::schema::PrimitiveType_GRU; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateGruParameter(const void *prim) { - auto *gru_param = reinterpret_cast(malloc(sizeof(GruParameter))); - if (gru_param == nullptr) { - MS_LOG(ERROR) << "malloc GruParameter failed."; - return nullptr; - } - memset(gru_param, 0, sizeof(GruParameter)); auto *primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - gru_param->op_parameter_.type_ = primitive->value_type(); - auto param = primitive->value_as_GRU(); - if (param == nullptr) { - free(gru_param); + auto value = primitive->value_as_GRU(); + if (value == nullptr) { MS_LOG(ERROR) << "param is nullptr."; return nullptr; } - gru_param->bidirectional_ = param->bidirectional(); - return reinterpret_cast(gru_param); + + auto *param = reinterpret_cast(malloc(sizeof(GruParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc GruParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(GruParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->bidirectional_ = value->bidirectional(); + return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_GRU, PopulateGruParameter, SCHEMA_CUR) } // namespace lite diff --git a/mindspore/lite/src/ops/populate/hashtable_lookup_populate.cc b/mindspore/lite/src/ops/populate/hashtable_lookup_populate.cc index 887c4c9b53..614e01eac2 100644 --- a/mindspore/lite/src/ops/populate/hashtable_lookup_populate.cc +++ b/mindspore/lite/src/ops/populate/hashtable_lookup_populate.cc @@ -19,17 +19,20 @@ using mindspore::schema::PrimitiveType_HashtableLookup; namespace mindspore { namespace lite { OpParameter *PopulateHashtableLookupParameter(const void *prim) { + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + auto *param = reinterpret_cast(malloc(sizeof(OpParameter))); if (param == nullptr) { MS_LOG(ERROR) << "new OpParameter failed."; return nullptr; } memset(param, 0, sizeof(OpParameter)); - auto primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); + param->type_ = primitive->value_type(); return param; } + REG_POPULATE(PrimitiveType_HashtableLookup, PopulateHashtableLookupParameter, SCHEMA_CUR); } // namespace lite diff --git a/mindspore/lite/src/ops/populate/instance_norm_populate.cc b/mindspore/lite/src/ops/populate/instance_norm_populate.cc index 02002deecb..346a5cdbf7 100644 --- a/mindspore/lite/src/ops/populate/instance_norm_populate.cc +++ b/mindspore/lite/src/ops/populate/instance_norm_populate.cc @@ -20,13 +20,6 @@ using mindspore::schema::PrimitiveType_InstanceNorm; namespace mindspore { namespace lite { OpParameter *PopulateInstanceNormParameter(const void *prim) { - auto *instance_norm_param = reinterpret_cast(malloc(sizeof(InstanceNormParameter))); - if (instance_norm_param == nullptr) { - MS_LOG(ERROR) << "malloc InstanceNormParameter failed."; - return nullptr; - } - memset(instance_norm_param, 0, sizeof(InstanceNormParameter)); - auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_InstanceNorm(); @@ -34,9 +27,17 @@ OpParameter *PopulateInstanceNormParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - instance_norm_param->op_parameter_.type_ = primitive->value_type(); - instance_norm_param->epsilon_ = value->epsilon(); - return reinterpret_cast(instance_norm_param); + + auto *param = reinterpret_cast(malloc(sizeof(InstanceNormParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc InstanceNormParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(InstanceNormParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->epsilon_ = value->epsilon(); + return reinterpret_cast(param); } REG_POPULATE(PrimitiveType_InstanceNorm, PopulateInstanceNormParameter, SCHEMA_CUR) diff --git a/mindspore/lite/src/ops/populate/l2_norm_populate.cc b/mindspore/lite/src/ops/populate/l2_norm_populate.cc index 16faf70721..f1ffcc1197 100644 --- a/mindspore/lite/src/ops/populate/l2_norm_populate.cc +++ b/mindspore/lite/src/ops/populate/l2_norm_populate.cc @@ -13,7 +13,6 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#include #include "src/ops/populate/populate_register.h" #include "nnacl/l2_norm_parameter.h" using mindspore::schema::PrimitiveType_L2NormalizeFusion; @@ -21,13 +20,6 @@ using mindspore::schema::PrimitiveType_L2NormalizeFusion; namespace mindspore { namespace lite { OpParameter *PopulateL2NormParameter(const void *prim) { - auto *l2_norm_parameter = reinterpret_cast(malloc(sizeof(L2NormParameter))); - if (l2_norm_parameter == nullptr) { - MS_LOG(ERROR) << "malloc L2NormParameter failed."; - return nullptr; - } - memset(l2_norm_parameter, 0, sizeof(L2NormParameter)); - auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_L2NormalizeFusion(); @@ -35,32 +27,40 @@ OpParameter *PopulateL2NormParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - l2_norm_parameter->op_parameter_.type_ = primitive->value_type(); + auto *param = reinterpret_cast(malloc(sizeof(L2NormParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc L2NormParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(L2NormParameter)); + + param->op_parameter_.type_ = primitive->value_type(); auto axis_vec = value->axis(); if (axis_vec == nullptr) { MS_LOG(ERROR) << "axis_vec is nullptr"; + free(param); return nullptr; } - l2_norm_parameter->axis_num_ = axis_vec->size(); + param->axis_num_ = axis_vec->size(); MS_ASSERT(axis_vec->size() < 8); for (size_t i = 0; i < axis_vec->size(); i++) { - l2_norm_parameter->axis_[i] = static_cast(axis_vec->Get(i)); + param->axis_[i] = static_cast(axis_vec->Get(i)); } if (value->epsilon() < 1e-6) { - l2_norm_parameter->epsilon_ = 1e-6; + param->epsilon_ = 1e-6; } else { - l2_norm_parameter->epsilon_ = value->epsilon(); + param->epsilon_ = value->epsilon(); } if (value->activation_type() == static_cast(schema::ActivationType_RELU)) { - l2_norm_parameter->act_type_ = ActType_Relu; + param->act_type_ = ActType_Relu; } else if (value->activation_type() == static_cast(schema::ActivationType_RELU6)) { - l2_norm_parameter->act_type_ = ActType_Relu6; + param->act_type_ = ActType_Relu6; } else { - l2_norm_parameter->act_type_ = ActType_No; + param->act_type_ = ActType_No; } - return reinterpret_cast(l2_norm_parameter); + return reinterpret_cast(param); } REG_POPULATE(PrimitiveType_L2NormalizeFusion, PopulateL2NormParameter, SCHEMA_CUR) } // namespace lite diff --git a/mindspore/lite/src/ops/populate/layer_norm_grad_populate.cc b/mindspore/lite/src/ops/populate/layer_norm_grad_populate.cc index 0d9583d6ff..d13bd35974 100644 --- a/mindspore/lite/src/ops/populate/layer_norm_grad_populate.cc +++ b/mindspore/lite/src/ops/populate/layer_norm_grad_populate.cc @@ -21,23 +21,25 @@ using mindspore::schema::PrimitiveType_LayerNormGrad; namespace mindspore { namespace lite { OpParameter *PopulateLayerNormGradParameter(const void *prim) { - auto layer_norm_grad_parameter = reinterpret_cast(malloc(sizeof(LayerNormGradParameter))); - if (layer_norm_grad_parameter == nullptr) { - MS_LOG(ERROR) << "malloc LayerNormParameter failed."; - return nullptr; - } - memset(layer_norm_grad_parameter, 0, sizeof(LayerNormGradParameter)); auto *primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - layer_norm_grad_parameter->op_parameter_.type_ = primitive->value_type(); - auto param = primitive->value_as_LayerNormGrad(); + auto value = primitive->value_as_LayerNormGrad(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } + + auto param = reinterpret_cast(malloc(sizeof(LayerNormGradParameter))); if (param == nullptr) { - MS_LOG(ERROR) << "param is nullptr"; + MS_LOG(ERROR) << "malloc LayerNormParameter failed."; return nullptr; } - layer_norm_grad_parameter->begin_norm_axis_ = param->begin_norm_axis(); - layer_norm_grad_parameter->begin_params_axis_ = param->begin_params_axis(); - return reinterpret_cast(layer_norm_grad_parameter); + memset(param, 0, sizeof(LayerNormGradParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->begin_norm_axis_ = value->begin_norm_axis(); + param->begin_params_axis_ = value->begin_params_axis(); + return reinterpret_cast(param); } REG_POPULATE(PrimitiveType_LayerNormGrad, PopulateLayerNormGradParameter, SCHEMA_CUR); diff --git a/mindspore/lite/src/ops/populate/layer_norm_populate.cc b/mindspore/lite/src/ops/populate/layer_norm_populate.cc index 73e9f78e40..af7daaedf5 100644 --- a/mindspore/lite/src/ops/populate/layer_norm_populate.cc +++ b/mindspore/lite/src/ops/populate/layer_norm_populate.cc @@ -17,28 +17,31 @@ #include #include "src/ops/populate/populate_register.h" using mindspore::schema::PrimitiveType_LayerNormFusion; + namespace mindspore { namespace lite { OpParameter *PopulateLayerNormParameter(const void *prim) { - auto layer_norm_parameter = reinterpret_cast(malloc(sizeof(LayerNormParameter))); - if (layer_norm_parameter == nullptr) { - MS_LOG(ERROR) << "malloc LayerNormParameter failed."; - return nullptr; - } - memset(layer_norm_parameter, 0, sizeof(LayerNormParameter)); auto *primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - layer_norm_parameter->op_parameter_.type_ = primitive->value_type(); - auto param = primitive->value_as_LayerNormFusion(); + auto value = primitive->value_as_LayerNormFusion(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } + + auto param = reinterpret_cast(malloc(sizeof(LayerNormParameter))); if (param == nullptr) { - MS_LOG(ERROR) << "param is nullptr"; + MS_LOG(ERROR) << "malloc LayerNormParameter failed."; return nullptr; } - layer_norm_parameter->epsilon_ = param->epsilon(); - layer_norm_parameter->elementwise_affine_ = param->elementwise_affine(); - layer_norm_parameter->begin_norm_axis_ = static_cast(param->begin_norm_axis()); - layer_norm_parameter->begin_params_axis_ = static_cast(param->begin_params_axis()); - return reinterpret_cast(layer_norm_parameter); + memset(param, 0, sizeof(LayerNormParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->epsilon_ = value->epsilon(); + param->elementwise_affine_ = value->elementwise_affine(); + param->begin_norm_axis_ = static_cast(value->begin_norm_axis()); + param->begin_params_axis_ = static_cast(value->begin_params_axis()); + return reinterpret_cast(param); } REG_POPULATE(PrimitiveType_LayerNormFusion, PopulateLayerNormParameter, SCHEMA_CUR) diff --git a/mindspore/lite/src/ops/populate/local_response_normalization_populate.cc b/mindspore/lite/src/ops/populate/local_response_normalization_populate.cc index b26f13fcf2..cfe7750147 100644 --- a/mindspore/lite/src/ops/populate/local_response_normalization_populate.cc +++ b/mindspore/lite/src/ops/populate/local_response_normalization_populate.cc @@ -20,12 +20,6 @@ using mindspore::schema::PrimitiveType_LRN; namespace mindspore { namespace lite { OpParameter *PopulateLocalResponseNormParameter(const void *prim) { - auto *lrn_param = reinterpret_cast(malloc(sizeof(LocalResponseNormParameter))); - if (lrn_param == nullptr) { - MS_LOG(ERROR) << "malloc LocalResponseNormParameter failed."; - return nullptr; - } - memset(lrn_param, 0, sizeof(LocalResponseNormParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_LRN(); @@ -33,12 +27,20 @@ OpParameter *PopulateLocalResponseNormParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - lrn_param->op_parameter_.type_ = primitive->value_type(); - lrn_param->depth_radius_ = value->depth_radius(); - lrn_param->bias_ = value->bias(); - lrn_param->alpha_ = value->alpha(); - lrn_param->beta_ = value->beta(); - return reinterpret_cast(lrn_param); + + auto *param = reinterpret_cast(malloc(sizeof(LocalResponseNormParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc LocalResponseNormParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(LocalResponseNormParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->depth_radius_ = value->depth_radius(); + param->bias_ = value->bias(); + param->alpha_ = value->alpha(); + param->beta_ = value->beta(); + return reinterpret_cast(param); } REG_POPULATE(PrimitiveType_LRN, PopulateLocalResponseNormParameter, SCHEMA_CUR); diff --git a/mindspore/lite/src/ops/populate/log_softmax_populate.cc b/mindspore/lite/src/ops/populate/log_softmax_populate.cc index ff7ea1bb12..9705524de2 100644 --- a/mindspore/lite/src/ops/populate/log_softmax_populate.cc +++ b/mindspore/lite/src/ops/populate/log_softmax_populate.cc @@ -19,26 +19,26 @@ using mindspore::schema::PrimitiveType_LogSoftmax; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateLogSoftmaxParameter(const void *prim) { - auto *log_softmax_param = reinterpret_cast(malloc(sizeof(SoftmaxParameter))); - if (log_softmax_param == nullptr) { - MS_LOG(ERROR) << "malloc LogSoftmaxParameter failed."; - return nullptr; - } - memset(log_softmax_param, 0, sizeof(SoftmaxParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - log_softmax_param->op_parameter_.type_ = primitive->value_type(); - auto prim_log_softmax = primitive->value_as_LogSoftmax(); - if (prim_log_softmax == nullptr) { - MS_LOG(ERROR) << "prim_log_softmax is nullptr"; + auto value = primitive->value_as_LogSoftmax(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } + + auto *param = reinterpret_cast(malloc(sizeof(SoftmaxParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc SoftmaxParameter failed."; return nullptr; } - log_softmax_param->axis_ = prim_log_softmax->axis(); - return reinterpret_cast(log_softmax_param); + memset(param, 0, sizeof(SoftmaxParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->axis_ = value->axis(); + return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_LogSoftmax, PopulateLogSoftmaxParameter, SCHEMA_CUR); } // namespace lite diff --git a/mindspore/lite/src/ops/populate/lsh_projection_populate.cc b/mindspore/lite/src/ops/populate/lsh_projection_populate.cc index 5f9a966e5b..50433b53c5 100644 --- a/mindspore/lite/src/ops/populate/lsh_projection_populate.cc +++ b/mindspore/lite/src/ops/populate/lsh_projection_populate.cc @@ -20,13 +20,6 @@ using mindspore::schema::PrimitiveType_LshProjection; namespace mindspore { namespace lite { OpParameter *PopulateLshProjectionParameter(const void *prim) { - auto *lsh_project_param = reinterpret_cast(malloc(sizeof(LshProjectionParameter))); - if (lsh_project_param == nullptr) { - MS_LOG(ERROR) << "malloc LshProjectionParameter failed."; - return nullptr; - } - memset(lsh_project_param, 0, sizeof(LshProjectionParameter)); - auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_LshProjection(); @@ -34,11 +27,19 @@ OpParameter *PopulateLshProjectionParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - lsh_project_param->op_parameter_.type_ = primitive->value_type(); - lsh_project_param->lsh_type_ = value->type(); - return reinterpret_cast(lsh_project_param); + + auto *param = reinterpret_cast(malloc(sizeof(LshProjectionParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc LshProjectionParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(LshProjectionParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->lsh_type_ = value->type(); + return reinterpret_cast(param); } -REG_POPULATE(PrimitiveType_LshProjection, PopulateLshProjectionParameter, SCHEMA_CUR); +REG_POPULATE(PrimitiveType_LshProjection, PopulateLshProjectionParameter, SCHEMA_CUR); } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/lstm_populate.cc b/mindspore/lite/src/ops/populate/lstm_populate.cc index 04bd36f4da..f4bfa59dbf 100644 --- a/mindspore/lite/src/ops/populate/lstm_populate.cc +++ b/mindspore/lite/src/ops/populate/lstm_populate.cc @@ -19,30 +19,29 @@ using mindspore::schema::PrimitiveType_LSTM; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateLstmParameter(const void *prim) { - auto *lstm_param = reinterpret_cast(malloc(sizeof(LstmParameter))); - if (lstm_param == nullptr) { - MS_LOG(ERROR) << "malloc LstmParameter failed."; - return nullptr; - } - memset(lstm_param, 0, sizeof(LstmParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - lstm_param->op_parameter_.type_ = primitive->value_type(); - auto param = primitive->value_as_LSTM(); + auto value = primitive->value_as_LSTM(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr."; + return nullptr; + } + + auto *param = reinterpret_cast(malloc(sizeof(LstmParameter))); if (param == nullptr) { - free(lstm_param); - MS_LOG(ERROR) << "get Lstm param nullptr."; + MS_LOG(ERROR) << "malloc LstmParameter failed."; return nullptr; } + memset(param, 0, sizeof(LstmParameter)); - lstm_param->bidirectional_ = param->bidirectional(); - lstm_param->zoneout_cell_ = param->zoneout_cell(); - lstm_param->zoneout_hidden_ = param->zoneout_hidden(); - return reinterpret_cast(lstm_param); + param->op_parameter_.type_ = primitive->value_type(); + param->bidirectional_ = value->bidirectional(); + param->zoneout_cell_ = value->zoneout_cell(); + param->zoneout_hidden_ = value->zoneout_hidden(); + return reinterpret_cast(param); } -} // namespace + REG_POPULATE(PrimitiveType_LSTM, PopulateLstmParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/matmul_populate.cc b/mindspore/lite/src/ops/populate/matmul_populate.cc index 167303b962..c4b13b43ba 100644 --- a/mindspore/lite/src/ops/populate/matmul_populate.cc +++ b/mindspore/lite/src/ops/populate/matmul_populate.cc @@ -16,15 +16,10 @@ #include "src/ops/populate/populate_register.h" #include "nnacl/matmul_parameter.h" using mindspore::schema::PrimitiveType_MatMul; + namespace mindspore { namespace lite { OpParameter *PopulateMatMulParameter(const void *prim) { - auto *matmul_param = reinterpret_cast(malloc(sizeof(MatMulParameter))); - if (matmul_param == nullptr) { - MS_LOG(ERROR) << "malloc MatMulParameter failed."; - return nullptr; - } - memset(matmul_param, 0, sizeof(MatMulParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_MatMul(); @@ -32,13 +27,22 @@ OpParameter *PopulateMatMulParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - matmul_param->op_parameter_.type_ = primitive->value_type(); - matmul_param->b_transpose_ = value->transpose_b(); - matmul_param->a_transpose_ = value->transpose_a(); - matmul_param->has_bias_ = false; - matmul_param->act_type_ = ActType_No; - return reinterpret_cast(matmul_param); + + auto *param = reinterpret_cast(malloc(sizeof(MatMulParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc MatMulParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(MatMulParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->b_transpose_ = value->transpose_b(); + param->a_transpose_ = value->transpose_a(); + param->has_bias_ = false; + param->act_type_ = ActType_No; + return reinterpret_cast(param); } + REG_POPULATE(PrimitiveType_MatMul, PopulateMatMulParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/merge_populate.cc b/mindspore/lite/src/ops/populate/merge_populate.cc index 59f79b61b1..2c6339cfe4 100644 --- a/mindspore/lite/src/ops/populate/merge_populate.cc +++ b/mindspore/lite/src/ops/populate/merge_populate.cc @@ -19,16 +19,18 @@ using mindspore::schema::PrimitiveType_Merge; namespace mindspore { namespace lite { OpParameter *PopulateMergeParameter(const void *prim) { - auto *merge_parameter = reinterpret_cast(malloc(sizeof(OpParameter))); - if (merge_parameter == nullptr) { - MS_LOG(ERROR) << "malloc Merge parameter failed."; - return nullptr; - } - memset(merge_parameter, 0, sizeof(OpParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - merge_parameter->type_ = primitive->value_type(); - return reinterpret_cast(merge_parameter); + + auto *param = reinterpret_cast(malloc(sizeof(OpParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc OpParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(OpParameter)); + + param->type_ = primitive->value_type(); + return reinterpret_cast(param); } REG_POPULATE(PrimitiveType_Merge, PopulateMergeParameter, SCHEMA_CUR) } // namespace lite diff --git a/mindspore/lite/src/ops/populate/mfcc_populate.cc b/mindspore/lite/src/ops/populate/mfcc_populate.cc index f133143892..f2c13cc8ab 100644 --- a/mindspore/lite/src/ops/populate/mfcc_populate.cc +++ b/mindspore/lite/src/ops/populate/mfcc_populate.cc @@ -19,26 +19,26 @@ using mindspore::schema::PrimitiveType_Mfcc; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateMfccParameter(const void *prim) { - auto *arg_param = reinterpret_cast(malloc(sizeof(MfccParameter))); - if (arg_param == nullptr) { - MS_LOG(ERROR) << "malloc MfccParameter failed."; - return nullptr; - } - memset(arg_param, 0, sizeof(MfccParameter)); auto *primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - arg_param->op_parameter_.type_ = primitive->value_type(); - auto param = primitive->value_as_Mfcc(); + auto value = primitive->value_as_Mfcc(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } + + auto *param = reinterpret_cast(malloc(sizeof(MfccParameter))); if (param == nullptr) { - MS_LOG(ERROR) << "param is nullptr"; + MS_LOG(ERROR) << "malloc MfccParameter failed."; return nullptr; } - arg_param->dct_coeff_num_ = param->dct_coeff_num(); - return reinterpret_cast(arg_param); + memset(param, 0, sizeof(MfccParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->dct_coeff_num_ = value->dct_coeff_num(); + return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_Mfcc, PopulateMfccParameter, SCHEMA_CUR) } // namespace lite diff --git a/mindspore/lite/src/ops/populate/mul_populate.cc b/mindspore/lite/src/ops/populate/mul_populate.cc index 3a908974ea..82491f834e 100644 --- a/mindspore/lite/src/ops/populate/mul_populate.cc +++ b/mindspore/lite/src/ops/populate/mul_populate.cc @@ -20,19 +20,19 @@ using mindspore::schema::PrimitiveType_MulFusion; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateMulParameter(const void *prim) { + auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + ArithmeticParameter *param = PopulateArithmeticCommonPara(prim); if (param == nullptr) { MS_LOG(ERROR) << "PopulateArithmeticCommonPara failed."; return nullptr; } - auto *primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); + param->op_parameter_.type_ = primitive->value_type(); return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_MulFusion, PopulateMulParameter, SCHEMA_CUR) } // namespace lite diff --git a/mindspore/lite/src/ops/populate/non_max_suppression_populate.cc b/mindspore/lite/src/ops/populate/non_max_suppression_populate.cc index 4f37f8d3ac..e37ca28f8d 100644 --- a/mindspore/lite/src/ops/populate/non_max_suppression_populate.cc +++ b/mindspore/lite/src/ops/populate/non_max_suppression_populate.cc @@ -20,12 +20,6 @@ using mindspore::schema::PrimitiveType_NonMaxSuppression; namespace mindspore { namespace lite { OpParameter *PopulateNonMaxSuppressionParameter(const void *prim) { - auto *param = reinterpret_cast(malloc(sizeof(NMSParameter))); - if (param == nullptr) { - MS_LOG(ERROR) << "malloc param failed."; - return nullptr; - } - memset(param, 0, sizeof(NMSParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_NonMaxSuppression(); @@ -33,6 +27,14 @@ OpParameter *PopulateNonMaxSuppressionParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } + + auto *param = reinterpret_cast(malloc(sizeof(NMSParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc NMSParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(NMSParameter)); + param->op_parameter_.type_ = primitive->value_type(); param->center_point_box_ = value->center_point_box(); return reinterpret_cast(param); diff --git a/mindspore/lite/src/ops/populate/one_hot_populate.cc b/mindspore/lite/src/ops/populate/one_hot_populate.cc index 588324de64..450959ce2d 100644 --- a/mindspore/lite/src/ops/populate/one_hot_populate.cc +++ b/mindspore/lite/src/ops/populate/one_hot_populate.cc @@ -20,13 +20,6 @@ using mindspore::schema::PrimitiveType_OneHot; namespace mindspore { namespace lite { OpParameter *PopulateOneHotParameter(const void *prim) { - auto *one_hot_param = reinterpret_cast(malloc(sizeof(OneHotParameter))); - if (one_hot_param == nullptr) { - MS_LOG(ERROR) << "malloc OneHotParameter failed."; - return nullptr; - } - memset(one_hot_param, 0, sizeof(OneHotParameter)); - auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_OneHot(); @@ -34,10 +27,19 @@ OpParameter *PopulateOneHotParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - one_hot_param->op_parameter_.type_ = primitive->value_type(); - one_hot_param->axis_ = value->axis(); - return reinterpret_cast(one_hot_param); + + auto *param = reinterpret_cast(malloc(sizeof(OneHotParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc OneHotParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(OneHotParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->axis_ = value->axis(); + return reinterpret_cast(param); } + REG_POPULATE(PrimitiveType_OneHot, PopulateOneHotParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/oneslike_populate.cc b/mindspore/lite/src/ops/populate/oneslike_populate.cc index ceb32274da..a18d3c85dd 100644 --- a/mindspore/lite/src/ops/populate/oneslike_populate.cc +++ b/mindspore/lite/src/ops/populate/oneslike_populate.cc @@ -19,14 +19,16 @@ using mindspore::schema::PrimitiveType_OnesLike; namespace mindspore { namespace lite { OpParameter *PopulateOnesLikeParameter(const void *prim) { + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + auto *param = reinterpret_cast(malloc(sizeof(OpParameter))); if (param == nullptr) { - MS_LOG(ERROR) << "malloc OnesLike Parameter failed."; + MS_LOG(ERROR) << "malloc OpParameter failed."; return nullptr; } memset(param, 0, sizeof(OpParameter)); - auto primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); + param->type_ = primitive->value_type(); return param; } diff --git a/mindspore/lite/src/ops/populate/p_relu_populate.cc b/mindspore/lite/src/ops/populate/p_relu_populate.cc index 4c5f76d24c..1ca9d13e99 100644 --- a/mindspore/lite/src/ops/populate/p_relu_populate.cc +++ b/mindspore/lite/src/ops/populate/p_relu_populate.cc @@ -20,12 +20,6 @@ using mindspore::schema::PrimitiveType_PReLUFusion; namespace mindspore { namespace lite { OpParameter *PopulatePReLUParameter(const void *prim) { - PReluParameter *param = reinterpret_cast(malloc(sizeof(PReluParameter))); - if (param == nullptr) { - MS_LOG(ERROR) << "malloc PReluParameter failed."; - return nullptr; - } - memset(param, 0, sizeof(PReluParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_PReLUFusion(); @@ -33,10 +27,19 @@ OpParameter *PopulatePReLUParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } + + auto *param = reinterpret_cast(malloc(sizeof(PReluParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc PReluParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(PReluParameter)); + param->op_parameter_.type_ = primitive->value_type(); param->channelShared = value->channel_shared(); return reinterpret_cast(param); } + REG_POPULATE(PrimitiveType_PReLUFusion, PopulatePReLUParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/pad_populate.cc b/mindspore/lite/src/ops/populate/pad_populate.cc index 4e031f19af..23a19d483f 100644 --- a/mindspore/lite/src/ops/populate/pad_populate.cc +++ b/mindspore/lite/src/ops/populate/pad_populate.cc @@ -20,12 +20,6 @@ using mindspore::schema::PrimitiveType_PadFusion; namespace mindspore { namespace lite { OpParameter *PopulatePadParameter(const void *prim) { - auto *pad_param = reinterpret_cast(malloc(sizeof(PadParameter))); - if (pad_param == nullptr) { - MS_LOG(ERROR) << "malloc PadParameter failed."; - return nullptr; - } - memset(pad_param, 0, sizeof(PadParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_PadFusion(); @@ -33,11 +27,20 @@ OpParameter *PopulatePadParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - pad_param->op_parameter_.type_ = primitive->value_type(); - pad_param->pad_mode_ = value->padding_mode(); - pad_param->constant_value_ = value->constant_value(); - return reinterpret_cast(pad_param); + + auto *param = reinterpret_cast(malloc(sizeof(PadParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc PadParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(PadParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->pad_mode_ = value->padding_mode(); + param->constant_value_ = value->constant_value(); + return reinterpret_cast(param); } + REG_POPULATE(PrimitiveType_PadFusion, PopulatePadParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/partial_populate.cc b/mindspore/lite/src/ops/populate/partial_populate.cc index 39d9c6dab1..bd82459608 100644 --- a/mindspore/lite/src/ops/populate/partial_populate.cc +++ b/mindspore/lite/src/ops/populate/partial_populate.cc @@ -19,14 +19,7 @@ using mindspore::schema::PrimitiveType_PartialFusion; namespace mindspore { namespace lite { - OpParameter *PopulatePartialParameter(const void *prim) { - auto *partial_parameter = reinterpret_cast(malloc(sizeof(PartialParameter))); - if (partial_parameter == nullptr) { - MS_LOG(ERROR) << "malloc partial parameter failed."; - return nullptr; - } - memset(partial_parameter, 0, sizeof(PartialParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_PartialFusion(); @@ -34,11 +27,19 @@ OpParameter *PopulatePartialParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - partial_parameter->op_parameter_.type_ = primitive->value_type(); - partial_parameter->sub_graph_index_ = value->sub_graph_index(); - return reinterpret_cast(partial_parameter); + auto *param = reinterpret_cast(malloc(sizeof(PartialParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc partial parameter failed."; + return nullptr; + } + memset(param, 0, sizeof(PartialParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->sub_graph_index_ = value->sub_graph_index(); + return reinterpret_cast(param); } + REG_POPULATE(PrimitiveType_PartialFusion, PopulatePartialParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/pooling_populate.cc b/mindspore/lite/src/ops/populate/pooling_populate.cc index 1b935772fc..1b1ed7eed8 100644 --- a/mindspore/lite/src/ops/populate/pooling_populate.cc +++ b/mindspore/lite/src/ops/populate/pooling_populate.cc @@ -20,155 +20,160 @@ using mindspore::schema::PrimitiveType_MaxPoolFusion; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateAvgPoolParameter(const void *primitive) { - auto *pooling_param = reinterpret_cast(malloc(sizeof(PoolingParameter))); - if (pooling_param == nullptr) { - MS_LOG(ERROR) << "malloc PoolingParameter failed."; - return nullptr; - } - memset(pooling_param, 0, sizeof(PoolingParameter)); auto pooling_prim = static_cast(primitive); MS_ASSERT(pooling_prim != nullptr); - pooling_param->op_parameter_.type_ = pooling_prim->value_type(); - auto pooling_primitive = pooling_prim->value_as_AvgPoolFusion(); - if (pooling_primitive == nullptr) { - MS_LOG(ERROR) << "pooling_primitive is nullptr"; + auto value = pooling_prim->value_as_AvgPoolFusion(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } + + auto *param = reinterpret_cast(malloc(sizeof(PoolingParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc PoolingParameter failed."; return nullptr; } - pooling_param->pool_mode_ = PoolMode_AvgPool; - pooling_param->global_ = pooling_primitive->global(); - auto strides = pooling_primitive->strides(); + memset(param, 0, sizeof(PoolingParameter)); + + param->op_parameter_.type_ = pooling_prim->value_type(); + param->pool_mode_ = PoolMode_AvgPool; + param->global_ = value->global(); + auto strides = value->strides(); if (strides == nullptr) { MS_LOG(ERROR) << "strides is nullptr"; + free(param); return nullptr; } - pooling_param->stride_w_ = static_cast(*(strides->begin() + 1)); - pooling_param->stride_h_ = static_cast(*(strides->begin())); - auto pad = pooling_primitive->pad(); + param->stride_w_ = static_cast(*(strides->begin() + 1)); + param->stride_h_ = static_cast(*(strides->begin())); + auto pad = value->pad(); if (pad != nullptr) { - pooling_param->pad_u_ = static_cast(*(pad->begin())); - pooling_param->pad_d_ = static_cast(*(pad->begin() + 1)); - pooling_param->pad_l_ = static_cast(*(pad->begin() + 2)); - pooling_param->pad_r_ = static_cast(*(pad->begin() + 3)); + param->pad_u_ = static_cast(*(pad->begin())); + param->pad_d_ = static_cast(*(pad->begin() + 1)); + param->pad_l_ = static_cast(*(pad->begin() + 2)); + param->pad_r_ = static_cast(*(pad->begin() + 3)); } - if (!pooling_param->global_) { - auto kernel_size = pooling_primitive->kernel_size(); + if (!param->global_) { + auto kernel_size = value->kernel_size(); if (kernel_size == nullptr) { MS_LOG(ERROR) << "kernel_size is nullptr"; + free(param); return nullptr; } - pooling_param->window_w_ = static_cast(*(kernel_size->begin() + 1)); - pooling_param->window_h_ = static_cast(*(kernel_size->begin())); + param->window_w_ = static_cast(*(kernel_size->begin() + 1)); + param->window_h_ = static_cast(*(kernel_size->begin())); } - auto round_mode = pooling_primitive->round_mode(); + auto round_mode = value->round_mode(); switch (round_mode) { case schema::RoundMode_FLOOR: - pooling_param->round_mode_ = RoundMode_Floor; + param->round_mode_ = RoundMode_Floor; break; case schema::RoundMode_CEIL: - pooling_param->round_mode_ = RoundMode_Ceil; + param->round_mode_ = RoundMode_Ceil; break; default: - pooling_param->round_mode_ = RoundMode_No; + param->round_mode_ = RoundMode_No; break; } - if (pooling_primitive->activation_type() == schema::ActivationType_RELU) { - pooling_param->act_type_ = ActType_Relu; - } else if (pooling_primitive->activation_type() == schema::ActivationType_RELU6) { - pooling_param->act_type_ = ActType_Relu6; + if (value->activation_type() == schema::ActivationType_RELU) { + param->act_type_ = ActType_Relu; + } else if (value->activation_type() == schema::ActivationType_RELU6) { + param->act_type_ = ActType_Relu6; } else { - pooling_param->act_type_ = ActType_No; + param->act_type_ = ActType_No; } - switch (pooling_primitive->pad_mode()) { + switch (value->pad_mode()) { case schema::PadMode_SAME: - pooling_param->pad_mode_ = Pad_same; + param->pad_mode_ = Pad_same; break; case schema::PadMode_VALID: - pooling_param->pad_mode_ = Pad_valid; + param->pad_mode_ = Pad_valid; break; default: - pooling_param->pad_mode_ = Pad_pad; + param->pad_mode_ = Pad_pad; break; } - return reinterpret_cast(pooling_param); + return reinterpret_cast(param); } OpParameter *PopulateMaxPoolParameter(const void *primitive) { - auto *pooling_param = reinterpret_cast(malloc(sizeof(PoolingParameter))); - if (pooling_param == nullptr) { - MS_LOG(ERROR) << "malloc PoolingParameter failed."; - return nullptr; - } - memset(pooling_param, 0, sizeof(PoolingParameter)); auto pooling_prim = static_cast(primitive); MS_ASSERT(pooling_prim != nullptr); - pooling_param->op_parameter_.type_ = pooling_prim->value_type(); - auto max_pool_prim = pooling_prim->value_as_MaxPoolFusion(); - if (max_pool_prim == nullptr) { - MS_LOG(ERROR) << "max_pool_prim is nullptr"; + auto value = pooling_prim->value_as_MaxPoolFusion(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } + + auto *param = reinterpret_cast(malloc(sizeof(PoolingParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc PoolingParameter failed."; return nullptr; } - pooling_param->pool_mode_ = PoolMode_MaxPool; - pooling_param->global_ = max_pool_prim->global(); - if (!pooling_param->global_) { - auto kernel_size = max_pool_prim->kernel_size(); - auto strides = max_pool_prim->strides(); + memset(param, 0, sizeof(PoolingParameter)); + + param->op_parameter_.type_ = pooling_prim->value_type(); + param->pool_mode_ = PoolMode_MaxPool; + param->global_ = value->global(); + if (!param->global_) { + auto kernel_size = value->kernel_size(); + auto strides = value->strides(); if (kernel_size == nullptr || strides == nullptr) { MS_LOG(ERROR) << "kernel_size or strides is nullptr"; + free(param); return nullptr; } - pooling_param->window_w_ = static_cast(*(kernel_size->begin() + 1)); - pooling_param->window_h_ = static_cast(*(kernel_size->begin())); - pooling_param->stride_w_ = static_cast(*(strides->begin() + 1)); - pooling_param->stride_h_ = static_cast(*(strides->begin())); - auto pad = max_pool_prim->pad(); + param->window_w_ = static_cast(*(kernel_size->begin() + 1)); + param->window_h_ = static_cast(*(kernel_size->begin())); + param->stride_w_ = static_cast(*(strides->begin() + 1)); + param->stride_h_ = static_cast(*(strides->begin())); + auto pad = value->pad(); if (pad != nullptr) { - pooling_param->pad_u_ = static_cast(*(pad->begin())); - pooling_param->pad_d_ = static_cast(*(pad->begin() + 1)); - pooling_param->pad_l_ = static_cast(*(pad->begin() + 2)); - pooling_param->pad_r_ = static_cast(*(pad->begin() + 3)); + param->pad_u_ = static_cast(*(pad->begin())); + param->pad_d_ = static_cast(*(pad->begin() + 1)); + param->pad_l_ = static_cast(*(pad->begin() + 2)); + param->pad_r_ = static_cast(*(pad->begin() + 3)); } } - auto round_mode = max_pool_prim->round_mode(); + auto round_mode = value->round_mode(); switch (round_mode) { case schema::RoundMode_FLOOR: - pooling_param->round_mode_ = RoundMode_Floor; + param->round_mode_ = RoundMode_Floor; break; case schema::RoundMode_CEIL: - pooling_param->round_mode_ = RoundMode_Ceil; + param->round_mode_ = RoundMode_Ceil; break; default: - pooling_param->round_mode_ = RoundMode_No; + param->round_mode_ = RoundMode_No; break; } - if (max_pool_prim->activation_type() == schema::ActivationType_RELU) { - pooling_param->act_type_ = ActType_Relu; - } else if (max_pool_prim->activation_type() == schema::ActivationType_RELU6) { - pooling_param->act_type_ = ActType_Relu6; + if (value->activation_type() == schema::ActivationType_RELU) { + param->act_type_ = ActType_Relu; + } else if (value->activation_type() == schema::ActivationType_RELU6) { + param->act_type_ = ActType_Relu6; } else { - pooling_param->act_type_ = ActType_No; + param->act_type_ = ActType_No; } - switch (max_pool_prim->pad_mode()) { + switch (value->pad_mode()) { case schema::PadMode_SAME: - pooling_param->pad_mode_ = Pad_same; + param->pad_mode_ = Pad_same; break; case schema::PadMode_VALID: - pooling_param->pad_mode_ = Pad_valid; + param->pad_mode_ = Pad_valid; break; default: - pooling_param->pad_mode_ = Pad_pad; + param->pad_mode_ = Pad_pad; break; } - return reinterpret_cast(pooling_param); + return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_AvgPoolFusion, PopulateAvgPoolParameter, SCHEMA_CUR) REG_POPULATE(PrimitiveType_MaxPoolFusion, PopulateMaxPoolParameter, SCHEMA_CUR) diff --git a/mindspore/lite/src/ops/populate/power_populate.cc b/mindspore/lite/src/ops/populate/power_populate.cc index db9d567934..4375e2bcc4 100644 --- a/mindspore/lite/src/ops/populate/power_populate.cc +++ b/mindspore/lite/src/ops/populate/power_populate.cc @@ -19,27 +19,27 @@ using mindspore::schema::PrimitiveType_PowFusion; namespace mindspore { namespace lite { -namespace { OpParameter *PopulatePowerParameter(const void *prim) { - auto *power_param = reinterpret_cast(malloc(sizeof(PowerParameter))); - if (power_param == nullptr) { - MS_LOG(ERROR) << "malloc PowerParameter failed."; - return nullptr; - } - memset(power_param, 0, sizeof(PowerParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - power_param->op_parameter_.type_ = primitive->value_type(); - auto power_prim = primitive->value_as_PowFusion(); - if (power_prim == nullptr) { - MS_LOG(ERROR) << "power_prim is nullptr"; + auto value = primitive->value_as_PowFusion(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } + + auto *param = reinterpret_cast(malloc(sizeof(PowerParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc PowerParameter failed."; return nullptr; } - power_param->scale_ = power_prim->scale(); - power_param->shift_ = power_prim->shift(); - return reinterpret_cast(power_param); + memset(param, 0, sizeof(PowerParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->scale_ = value->scale(); + param->shift_ = value->shift(); + return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_PowFusion, PopulatePowerParameter, SCHEMA_CUR) } // namespace lite diff --git a/mindspore/lite/src/ops/populate/prior_box_populate.cc b/mindspore/lite/src/ops/populate/prior_box_populate.cc index 87ec3a07b6..21874f83aa 100644 --- a/mindspore/lite/src/ops/populate/prior_box_populate.cc +++ b/mindspore/lite/src/ops/populate/prior_box_populate.cc @@ -20,13 +20,6 @@ using mindspore::schema::PrimitiveType_PriorBox; namespace mindspore { namespace lite { OpParameter *PopulatePriorBoxParameter(const void *prim) { - auto *prior_box_param = reinterpret_cast(malloc(sizeof(PriorBoxParameter))); - if (prior_box_param == nullptr) { - MS_LOG(ERROR) << "malloc PriorBoxParameter failed."; - return nullptr; - } - memset(prior_box_param, 0, sizeof(PriorBoxParameter)); - auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_PriorBox(); @@ -34,67 +27,80 @@ OpParameter *PopulatePriorBoxParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - prior_box_param->op_parameter_.type_ = primitive->value_type(); + + auto *param = reinterpret_cast(malloc(sizeof(PriorBoxParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc PriorBoxParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(PriorBoxParameter)); + + param->op_parameter_.type_ = primitive->value_type(); auto min_sizes = value->min_sizes(); if (min_sizes == nullptr) { MS_LOG(ERROR) << "min_sizes is nullptr"; + free(param); return nullptr; } if (min_sizes->size() > MAX_SHAPE_SIZE) { MS_LOG(ERROR) << "PriorBox min_sizes size exceeds max num " << MAX_SHAPE_SIZE << ", got " << min_sizes->size(); - free(prior_box_param); + free(param); return nullptr; } - prior_box_param->min_sizes_size = min_sizes->size(); - memcpy(prior_box_param->min_sizes, min_sizes->data(), min_sizes->size() * sizeof(int32_t)); + param->min_sizes_size = min_sizes->size(); + memcpy(param->min_sizes, min_sizes->data(), min_sizes->size() * sizeof(int32_t)); auto max_sizes = value->max_sizes(); if (max_sizes == nullptr) { MS_LOG(ERROR) << "max_sizes is nullptr"; + free(param); return nullptr; } if (max_sizes->size() > MAX_SHAPE_SIZE) { MS_LOG(ERROR) << "PriorBox max_sizes size exceeds max num " << MAX_SHAPE_SIZE << ", got " << max_sizes->size(); - free(prior_box_param); + free(param); return nullptr; } - prior_box_param->max_sizes_size = max_sizes->size(); - memcpy(prior_box_param->max_sizes, max_sizes->data(), max_sizes->size() * sizeof(int32_t)); + param->max_sizes_size = max_sizes->size(); + memcpy(param->max_sizes, max_sizes->data(), max_sizes->size() * sizeof(int32_t)); auto aspect_ratios = value->aspect_ratios(); if (aspect_ratios == nullptr) { MS_LOG(ERROR) << "aspect_ratios is nullptr"; + free(param); return nullptr; } if (aspect_ratios->size() > MAX_SHAPE_SIZE) { MS_LOG(ERROR) << "PriorBox aspect_ratios size exceeds max num " << MAX_SHAPE_SIZE << ", got " << aspect_ratios->size(); - free(prior_box_param); + free(param); return nullptr; } - prior_box_param->aspect_ratios_size = aspect_ratios->size(); - memcpy(prior_box_param->aspect_ratios, aspect_ratios->data(), aspect_ratios->size() * sizeof(float)); + param->aspect_ratios_size = aspect_ratios->size(); + memcpy(param->aspect_ratios, aspect_ratios->data(), aspect_ratios->size() * sizeof(float)); auto variances = value->variances(); if (variances == nullptr) { MS_LOG(ERROR) << "variances is nullptr"; + free(param); return nullptr; } if (variances->size() != COMM_SHAPE_SIZE) { MS_LOG(ERROR) << "PriorBox variances size should be " << COMM_SHAPE_SIZE << ", got " << variances->size(); - free(prior_box_param); + free(param); return nullptr; } - memcpy(prior_box_param->variances, variances->data(), COMM_SHAPE_SIZE * sizeof(float)); - prior_box_param->flip = value->flip(); - prior_box_param->clip = value->clip(); - prior_box_param->offset = value->offset(); - prior_box_param->image_size_h = value->image_size_h(); - prior_box_param->image_size_w = value->image_size_w(); - prior_box_param->step_h = value->step_h(); - prior_box_param->step_w = value->step_w(); - return reinterpret_cast(prior_box_param); + memcpy(param->variances, variances->data(), COMM_SHAPE_SIZE * sizeof(float)); + param->flip = value->flip(); + param->clip = value->clip(); + param->offset = value->offset(); + param->image_size_h = value->image_size_h(); + param->image_size_w = value->image_size_w(); + param->step_h = value->step_h(); + param->step_w = value->step_w(); + return reinterpret_cast(param); } + REG_POPULATE(PrimitiveType_PriorBox, PopulatePriorBoxParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/quant_dtype_cast_populate.cc b/mindspore/lite/src/ops/populate/quant_dtype_cast_populate.cc index d0a5913659..2d49c71e2f 100644 --- a/mindspore/lite/src/ops/populate/quant_dtype_cast_populate.cc +++ b/mindspore/lite/src/ops/populate/quant_dtype_cast_populate.cc @@ -20,12 +20,6 @@ using mindspore::schema::PrimitiveType_QuantDTypeCast; namespace mindspore { namespace lite { OpParameter *PopulateQuantDTypeCastParameter(const void *prim) { - auto *parameter = reinterpret_cast(malloc(sizeof(QuantDTypeCastParameter))); - if (parameter == nullptr) { - MS_LOG(ERROR) << "malloc QuantDTypeCastParameter failed."; - return nullptr; - } - memset(parameter, 0, sizeof(QuantDTypeCastParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_QuantDTypeCast(); @@ -33,12 +27,20 @@ OpParameter *PopulateQuantDTypeCastParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - parameter->op_parameter_.type_ = primitive->value_type(); - parameter->srcT = value->src_t(); - parameter->dstT = value->dst_t(); - return reinterpret_cast(parameter); + + auto *param = reinterpret_cast(malloc(sizeof(QuantDTypeCastParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc QuantDTypeCastParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(QuantDTypeCastParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->srcT = value->src_t(); + param->dstT = value->dst_t(); + return reinterpret_cast(param); } -REG_POPULATE(PrimitiveType_QuantDTypeCast, PopulateQuantDTypeCastParameter, SCHEMA_CUR); +REG_POPULATE(PrimitiveType_QuantDTypeCast, PopulateQuantDTypeCastParameter, SCHEMA_CUR); } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/random_standard_normal_populate.cc b/mindspore/lite/src/ops/populate/random_standard_normal_populate.cc index 446d6d70b9..c5f3e3d5ee 100644 --- a/mindspore/lite/src/ops/populate/random_standard_normal_populate.cc +++ b/mindspore/lite/src/ops/populate/random_standard_normal_populate.cc @@ -22,25 +22,28 @@ namespace mindspore { namespace lite { namespace { OpParameter *PopulateRandomStandardNormalParameter(const void *prim) { - auto *random_parameter = reinterpret_cast(malloc(sizeof(RandomParam))); - if (random_parameter == nullptr) { - MS_LOG(ERROR) << "malloc RandomStandardNormal parameter failed."; - return nullptr; - } - memset(random_parameter, 0, sizeof(RandomParam)); auto *primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - random_parameter->op_parameter_.type_ = primitive->value_type(); - auto param = primitive->value_as_RandomStandardNormal(); + auto value = primitive->value_as_RandomStandardNormal(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } + + auto *param = reinterpret_cast(malloc(sizeof(RandomParam))); if (param == nullptr) { - MS_LOG(ERROR) << "param is nullptr"; + MS_LOG(ERROR) << "malloc RandomParam failed."; return nullptr; } - random_parameter->seed_ = param->seed(); - random_parameter->seed2_ = param->seed2(); - return reinterpret_cast(random_parameter); + memset(param, 0, sizeof(RandomParam)); + + param->op_parameter_.type_ = primitive->value_type(); + param->seed_ = value->seed(); + param->seed2_ = value->seed2(); + return reinterpret_cast(param); } } // namespace + REG_POPULATE(PrimitiveType_RandomStandardNormal, PopulateRandomStandardNormalParameter, SCHEMA_CUR); } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/range_populate.cc b/mindspore/lite/src/ops/populate/range_populate.cc index 3517fa7fcd..69554526aa 100644 --- a/mindspore/lite/src/ops/populate/range_populate.cc +++ b/mindspore/lite/src/ops/populate/range_populate.cc @@ -19,29 +19,30 @@ using mindspore::schema::PrimitiveType_Range; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateRangeParameter(const void *prim) { - auto *range_param = reinterpret_cast(malloc(sizeof(RangeParameter))); - if (range_param == nullptr) { - MS_LOG(ERROR) << "malloc RangeParameter failed."; - return nullptr; - } - memset(range_param, 0, sizeof(RangeParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - range_param->op_parameter_.type_ = primitive->value_type(); - auto range_prim = primitive->value_as_Range(); - if (range_prim == nullptr) { - MS_LOG(ERROR) << "range_prim is nullptr"; + auto value = primitive->value_as_Range(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - range_param->start_ = range_prim->start(); - range_param->limit_ = range_prim->limit(); - range_param->delta_ = range_prim->delta(); - range_param->dType_ = range_prim->d_type(); - return reinterpret_cast(range_param); + + auto *param = reinterpret_cast(malloc(sizeof(RangeParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc RangeParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(RangeParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->start_ = value->start(); + param->limit_ = value->limit(); + param->delta_ = value->delta(); + param->dType_ = value->d_type(); + return reinterpret_cast(param); } -} // namespace + REG_POPULATE(PrimitiveType_Range, PopulateRangeParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/rank_populate.cc b/mindspore/lite/src/ops/populate/rank_populate.cc index f0c2e5f3a0..30b9fa05d6 100644 --- a/mindspore/lite/src/ops/populate/rank_populate.cc +++ b/mindspore/lite/src/ops/populate/rank_populate.cc @@ -18,20 +18,20 @@ using mindspore::schema::PrimitiveType_Rank; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateRankParameter(const void *prim) { - auto *rank_param = reinterpret_cast(malloc(sizeof(OpParameter))); - if (rank_param == nullptr) { + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + + auto *param = reinterpret_cast(malloc(sizeof(OpParameter))); + if (param == nullptr) { MS_LOG(ERROR) << "malloc RankParameter failed."; return nullptr; } - memset(rank_param, 0, sizeof(OpParameter)); - auto primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); - rank_param->type_ = primitive->value_type(); - return reinterpret_cast(rank_param); + memset(param, 0, sizeof(OpParameter)); + + param->type_ = primitive->value_type(); + return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_Rank, PopulateRankParameter, SCHEMA_CUR) } // namespace lite diff --git a/mindspore/lite/src/ops/populate/reduce_populate.cc b/mindspore/lite/src/ops/populate/reduce_populate.cc index bce3524c3e..16f5252c33 100644 --- a/mindspore/lite/src/ops/populate/reduce_populate.cc +++ b/mindspore/lite/src/ops/populate/reduce_populate.cc @@ -13,19 +13,13 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#include #include "src/ops/populate/populate_register.h" #include "nnacl/reduce_parameter.h" using mindspore::schema::PrimitiveType_ReduceFusion; + namespace mindspore { namespace lite { OpParameter *PopulateReduceParameter(const void *prim) { - auto *reduce_param = reinterpret_cast(malloc(sizeof(ReduceParameter))); - if (reduce_param == nullptr) { - MS_LOG(ERROR) << "malloc ReduceParameter failed."; - return nullptr; - } - memset(reduce_param, 0, sizeof(ReduceParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_ReduceFusion(); @@ -33,15 +27,22 @@ OpParameter *PopulateReduceParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - reduce_param->op_parameter_.type_ = primitive->value_type(); - reduce_param->keep_dims_ = value->keep_dims(); - reduce_param->reduce_to_end_ = value->reduce_to_end(); - reduce_param->coeff = value->coeff(); - reduce_param->mode_ = static_cast(value->mode()); - return reinterpret_cast(reduce_param); + + auto *param = reinterpret_cast(malloc(sizeof(ReduceParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc ReduceParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(ReduceParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->keep_dims_ = value->keep_dims(); + param->reduce_to_end_ = value->reduce_to_end(); + param->coeff = value->coeff(); + param->mode_ = static_cast(value->mode()); + return reinterpret_cast(param); } REG_POPULATE(PrimitiveType_ReduceFusion, PopulateReduceParameter, SCHEMA_CUR) - } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/reshape_populate.cc b/mindspore/lite/src/ops/populate/reshape_populate.cc index ebee23e806..ddcd204512 100644 --- a/mindspore/lite/src/ops/populate/reshape_populate.cc +++ b/mindspore/lite/src/ops/populate/reshape_populate.cc @@ -19,20 +19,20 @@ using mindspore::schema::PrimitiveType_Reshape; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateReshapeParameter(const void *prim) { - auto *reshape_param = reinterpret_cast(malloc(sizeof(ReshapeParameter))); - if (reshape_param == nullptr) { + auto *primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + + auto *param = reinterpret_cast(malloc(sizeof(ReshapeParameter))); + if (param == nullptr) { MS_LOG(ERROR) << "malloc ReshapeParameter failed."; return nullptr; } - memset(reshape_param, 0, sizeof(ReshapeParameter)); - auto *primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); - reshape_param->op_parameter_.type_ = primitive->value_type(); - return reinterpret_cast(reshape_param); + memset(param, 0, sizeof(ReshapeParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_Reshape, PopulateReshapeParameter, SCHEMA_CUR) } // namespace lite diff --git a/mindspore/lite/src/ops/populate/resize_populate.cc b/mindspore/lite/src/ops/populate/resize_populate.cc index f4c2ca6357..95cde792d2 100644 --- a/mindspore/lite/src/ops/populate/resize_populate.cc +++ b/mindspore/lite/src/ops/populate/resize_populate.cc @@ -20,12 +20,6 @@ using mindspore::schema::PrimitiveType_Resize; namespace mindspore { namespace lite { OpParameter *PopulateResizeParameter(const void *prim) { - auto *resize_param = reinterpret_cast(malloc(sizeof(ResizeParameter))); - if (resize_param == nullptr) { - MS_LOG(ERROR) << "malloc ResizeParameter failed."; - return nullptr; - } - memset(resize_param, 0, sizeof(ResizeParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_Resize(); @@ -33,18 +27,24 @@ OpParameter *PopulateResizeParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - resize_param->op_parameter_.type_ = primitive->value_type(); - resize_param->method_ = static_cast(value->method()); - resize_param->new_height_ = value->new_height(); - resize_param->new_width_ = value->new_width(); - resize_param->coordinate_transform_mode_ = value->coordinate_transform_mode(); - resize_param->preserve_aspect_ratio_ = value->preserve_aspect_ratio(); - resize_param->cubic_coeff_ = value->cubic_coeff(); - return reinterpret_cast(resize_param); + auto *param = reinterpret_cast(malloc(sizeof(ResizeParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc ResizeParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(ResizeParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->method_ = static_cast(value->method()); + param->new_height_ = value->new_height(); + param->new_width_ = value->new_width(); + param->coordinate_transform_mode_ = value->coordinate_transform_mode(); + param->preserve_aspect_ratio_ = value->preserve_aspect_ratio(); + param->cubic_coeff_ = value->cubic_coeff(); + return reinterpret_cast(param); } REG_POPULATE(PrimitiveType_Resize, PopulateResizeParameter, SCHEMA_CUR) } // namespace lite - } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/reverse_populate.cc b/mindspore/lite/src/ops/populate/reverse_populate.cc index c70e7bbec5..987603db08 100644 --- a/mindspore/lite/src/ops/populate/reverse_populate.cc +++ b/mindspore/lite/src/ops/populate/reverse_populate.cc @@ -20,12 +20,6 @@ using mindspore::schema::PrimitiveType_ReverseV2; namespace mindspore { namespace lite { OpParameter *PopulateReverseParameter(const void *prim) { - auto *reverse_param = reinterpret_cast(malloc(sizeof(ReverseParameter))); - if (reverse_param == nullptr) { - MS_LOG(ERROR) << "malloc ReverseParameter failed."; - return nullptr; - } - memset(reverse_param, 0, sizeof(ReverseParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_ReverseV2(); @@ -33,19 +27,27 @@ OpParameter *PopulateReverseParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - reverse_param->op_parameter_.type_ = primitive->value_type(); + auto *param = reinterpret_cast(malloc(sizeof(ReverseParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc ReverseParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(ReverseParameter)); + + param->op_parameter_.type_ = primitive->value_type(); auto flatAxis = value->axis(); if (flatAxis == nullptr) { MS_LOG(ERROR) << "flatAxis is nullptr"; + free(param); return nullptr; } - reverse_param->num_axis_ = flatAxis->size(); + param->num_axis_ = flatAxis->size(); int i = 0; - for (auto iter = flatAxis->begin(); iter != flatAxis->end(); iter++) { - reverse_param->axis_[i++] = *iter; + for (auto flatAxi : *flatAxis) { + param->axis_[i++] = static_cast(flatAxi); } - return reinterpret_cast(reverse_param); + return reinterpret_cast(param); } REG_POPULATE(PrimitiveType_ReverseV2, PopulateReverseParameter, SCHEMA_CUR) diff --git a/mindspore/lite/src/ops/populate/reverse_sequence_populate.cc b/mindspore/lite/src/ops/populate/reverse_sequence_populate.cc index 129d8d9539..f38ea1d9bf 100644 --- a/mindspore/lite/src/ops/populate/reverse_sequence_populate.cc +++ b/mindspore/lite/src/ops/populate/reverse_sequence_populate.cc @@ -19,29 +19,28 @@ using mindspore::schema::PrimitiveType_ReverseSequence; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateReverseSequenceParameter(const void *prim) { - auto *reverse_sequence_param = reinterpret_cast(malloc(sizeof(ReverseSequenceParameter))); - if (reverse_sequence_param == nullptr) { - MS_LOG(ERROR) << "malloc ReverseSequenceParameter failed."; - return nullptr; - } - memset(reverse_sequence_param, 0, sizeof(ReverseSequenceParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - auto param = primitive->value_as_ReverseSequence(); + auto value = primitive->value_as_ReverseSequence(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } + + auto *param = reinterpret_cast(malloc(sizeof(ReverseSequenceParameter))); if (param == nullptr) { - MS_LOG(ERROR) << "param is nullptr"; + MS_LOG(ERROR) << "malloc ReverseSequenceParameter failed."; return nullptr; } - reverse_sequence_param->op_parameter_.type_ = primitive->value_type(); - reverse_sequence_param->seq_axis_ = static_cast(param->seq_dim()); - reverse_sequence_param->batch_axis_ = static_cast(param->batch_dim()); - return reinterpret_cast(reverse_sequence_param); + memset(param, 0, sizeof(ReverseSequenceParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->seq_axis_ = static_cast(value->seq_dim()); + param->batch_axis_ = static_cast(value->batch_dim()); + return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_ReverseSequence, PopulateReverseSequenceParameter, SCHEMA_CUR); - } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/roi_pooling_populate.cc b/mindspore/lite/src/ops/populate/roi_pooling_populate.cc index 120969f741..90a5b7a0d7 100644 --- a/mindspore/lite/src/ops/populate/roi_pooling_populate.cc +++ b/mindspore/lite/src/ops/populate/roi_pooling_populate.cc @@ -19,29 +19,28 @@ using mindspore::schema::PrimitiveType_ROIPooling; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateROIPoolingParameter(const void *prim) { - auto *roi_param = reinterpret_cast(malloc(sizeof(ROIPoolingParameter))); - if (roi_param == nullptr) { - MS_LOG(ERROR) << "malloc ROIPoolingParameter failed."; + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + auto value = primitive->value_as_ROIPooling(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - memset(roi_param, 0, sizeof(ROIPoolingParameter)); - auto primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); - roi_param->op_parameter_.type_ = primitive->value_type(); - auto roi_prim = primitive->value_as_ROIPooling(); - if (roi_prim == nullptr) { - MS_LOG(ERROR) << "roi_prim is nullptr"; + auto *param = reinterpret_cast(malloc(sizeof(ROIPoolingParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc ROIPoolingParameter failed."; return nullptr; } - roi_param->pooledH_ = roi_prim->pooled_h(); - roi_param->pooledW_ = roi_prim->pooled_w(); - roi_param->scale_ = roi_prim->scale(); - return reinterpret_cast(roi_param); + memset(param, 0, sizeof(ROIPoolingParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->pooledH_ = value->pooled_h(); + param->pooledW_ = value->pooled_w(); + param->scale_ = value->scale(); + return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_ROIPooling, PopulateROIPoolingParameter, SCHEMA_CUR) } // namespace lite diff --git a/mindspore/lite/src/ops/populate/scale_populate.cc b/mindspore/lite/src/ops/populate/scale_populate.cc index bfdde39591..32174280bb 100644 --- a/mindspore/lite/src/ops/populate/scale_populate.cc +++ b/mindspore/lite/src/ops/populate/scale_populate.cc @@ -19,14 +19,7 @@ using mindspore::schema::PrimitiveType_ScaleFusion; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateScaleParameter(const void *prim) { - auto *scale_param = reinterpret_cast(malloc(sizeof(ScaleParameter))); - if (scale_param == nullptr) { - MS_LOG(ERROR) << "malloc ScaleParameter failed."; - return nullptr; - } - memset(scale_param, 0, sizeof(ScaleParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_ScaleFusion(); @@ -34,12 +27,19 @@ OpParameter *PopulateScaleParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - scale_param->op_parameter_.type_ = primitive->value_type(); - scale_param->axis_ = value->axis(); - scale_param->activation_type_ = value->activation_type(); - return reinterpret_cast(scale_param); + + auto *param = reinterpret_cast(malloc(sizeof(ScaleParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc ScaleParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(ScaleParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->axis_ = value->axis(); + param->activation_type_ = value->activation_type(); + return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_ScaleFusion, PopulateScaleParameter, SCHEMA_CUR) } // namespace lite diff --git a/mindspore/lite/src/ops/populate/scatter_nd_populate.cc b/mindspore/lite/src/ops/populate/scatter_nd_populate.cc index f6e4c4b3e7..0e3506693b 100644 --- a/mindspore/lite/src/ops/populate/scatter_nd_populate.cc +++ b/mindspore/lite/src/ops/populate/scatter_nd_populate.cc @@ -18,20 +18,21 @@ using mindspore::schema::PrimitiveType_ScatterNd; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateScatterNDParameter(const void *prim) { - auto *scatter_nd_param = reinterpret_cast(malloc(sizeof(OpParameter))); - if (scatter_nd_param == nullptr) { + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + + auto *param = reinterpret_cast(malloc(sizeof(OpParameter))); + if (param == nullptr) { MS_LOG(ERROR) << "malloc ScatterNDParameter failed."; return nullptr; } - memset(scatter_nd_param, 0, sizeof(OpParameter)); - auto primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); - scatter_nd_param->type_ = primitive->value_type(); - return reinterpret_cast(scatter_nd_param); + memset(param, 0, sizeof(OpParameter)); + + param->type_ = primitive->value_type(); + return reinterpret_cast(param); } -} // namespace + REG_POPULATE(PrimitiveType_ScatterNd, PopulateScatterNDParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/shape_populate.cc b/mindspore/lite/src/ops/populate/shape_populate.cc index 2cd62c691c..b3b316168c 100644 --- a/mindspore/lite/src/ops/populate/shape_populate.cc +++ b/mindspore/lite/src/ops/populate/shape_populate.cc @@ -20,20 +20,20 @@ using mindspore::schema::PrimitiveType_Shape; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateShapeParameter(const void *prim) { - auto *shape_param = reinterpret_cast(malloc(sizeof(OpParameter))); - if (shape_param == nullptr) { + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + + auto *param = reinterpret_cast(malloc(sizeof(OpParameter))); + if (param == nullptr) { MS_LOG(ERROR) << "malloc ShapeParameter failed."; return nullptr; } - memset(shape_param, 0, sizeof(OpParameter)); - auto primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); - shape_param->type_ = primitive->value_type(); - return reinterpret_cast(shape_param); + memset(param, 0, sizeof(OpParameter)); + + param->type_ = primitive->value_type(); + return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_Shape, PopulateShapeParameter, SCHEMA_CUR) } // namespace lite diff --git a/mindspore/lite/src/ops/populate/skip_gram_populate.cc b/mindspore/lite/src/ops/populate/skip_gram_populate.cc index 4f33ff961f..d1954855ba 100644 --- a/mindspore/lite/src/ops/populate/skip_gram_populate.cc +++ b/mindspore/lite/src/ops/populate/skip_gram_populate.cc @@ -20,12 +20,6 @@ using mindspore::schema::PrimitiveType_SkipGram; namespace mindspore { namespace lite { OpParameter *PopulateSkipGramParameter(const void *prim) { - auto *skipGramParameter = reinterpret_cast(malloc(sizeof(SkipGramParameter))); - if (skipGramParameter == nullptr) { - MS_LOG(ERROR) << "malloc SkipGramParameter failed."; - return nullptr; - } - memset(skipGramParameter, 0, sizeof(SkipGramParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_SkipGram(); @@ -33,12 +27,21 @@ OpParameter *PopulateSkipGramParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - skipGramParameter->op_parameter_.type_ = primitive->value_type(); - skipGramParameter->ngram_size = value->ngram_size(); - skipGramParameter->max_skip_size = value->max_skip_size(); - skipGramParameter->include_all_ngrams = value->include_all_grams(); - return reinterpret_cast(skipGramParameter); + + auto *param = reinterpret_cast(malloc(sizeof(SkipGramParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc SkipGramParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(SkipGramParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->ngram_size = value->ngram_size(); + param->max_skip_size = value->max_skip_size(); + param->include_all_ngrams = value->include_all_grams(); + return reinterpret_cast(param); } + REG_POPULATE(PrimitiveType_SkipGram, PopulateSkipGramParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/slice_populate.cc b/mindspore/lite/src/ops/populate/slice_populate.cc index 3be4f9962e..422439547d 100644 --- a/mindspore/lite/src/ops/populate/slice_populate.cc +++ b/mindspore/lite/src/ops/populate/slice_populate.cc @@ -20,12 +20,6 @@ using mindspore::schema::PrimitiveType_SliceFusion; namespace mindspore { namespace lite { OpParameter *PopulateSliceParameter(const void *prim) { - auto *slice_param = reinterpret_cast(malloc(sizeof(SliceParameter))); - if (slice_param == nullptr) { - MS_LOG(ERROR) << "malloc SliceParameter failed."; - return nullptr; - } - memset(slice_param, 0, sizeof(SliceParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_SliceFusion(); @@ -33,17 +27,27 @@ OpParameter *PopulateSliceParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - slice_param->op_parameter_.type_ = primitive->value_type(); + + auto *param = reinterpret_cast(malloc(sizeof(SliceParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc SliceParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(SliceParameter)); + + param->op_parameter_.type_ = primitive->value_type(); auto axes = value->axes(); if (axes == nullptr) { MS_LOG(ERROR) << "axes is nullptr"; + free(param); return nullptr; } for (size_t i = 0; i < axes->size(); ++i) { - slice_param->axis_[i] = axes->Get(i); + param->axis_[i] = axes->Get(i); } - return reinterpret_cast(slice_param); + return reinterpret_cast(param); } + REG_POPULATE(PrimitiveType_SliceFusion, PopulateSliceParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/softmax_populate.cc b/mindspore/lite/src/ops/populate/softmax_populate.cc index f3c0f7febf..4e518d8b80 100644 --- a/mindspore/lite/src/ops/populate/softmax_populate.cc +++ b/mindspore/lite/src/ops/populate/softmax_populate.cc @@ -19,36 +19,37 @@ using mindspore::schema::PrimitiveType_Softmax; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateSoftmaxParameter(const void *prim) { - auto *softmax_param = reinterpret_cast(malloc(sizeof(SoftmaxParameter))); - if (softmax_param == nullptr) { - MS_LOG(ERROR) << "malloc SoftmaxParameter failed."; - return nullptr; - } - memset(softmax_param, 0, sizeof(SoftmaxParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - softmax_param->op_parameter_.type_ = primitive->value_type(); - auto prim_softmax = primitive->value_as_Softmax(); - if (prim_softmax == nullptr) { - MS_LOG(ERROR) << "prim_softmax is nullptr"; + auto value = primitive->value_as_Softmax(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } + + auto *param = reinterpret_cast(malloc(sizeof(SoftmaxParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc SoftmaxParameter failed."; return nullptr; } - auto axis = prim_softmax->axis(); + memset(param, 0, sizeof(SoftmaxParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + auto axis = value->axis(); if (axis == nullptr) { MS_LOG(ERROR) << "axis is nullptr"; + free(param); return nullptr; } if (axis->size() != 1) { MS_LOG(ERROR) << "axis number invalid!number: " << axis->size(); - free(softmax_param); + free(param); return nullptr; } - softmax_param->axis_ = axis->data()[0]; - return reinterpret_cast(softmax_param); + param->axis_ = axis->data()[0]; + return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_Softmax, PopulateSoftmaxParameter, SCHEMA_CUR) } // namespace lite diff --git a/mindspore/lite/src/ops/populate/space_to_batch_nd_populate.cc b/mindspore/lite/src/ops/populate/space_to_batch_nd_populate.cc index a8d81f4122..241715cfc1 100644 --- a/mindspore/lite/src/ops/populate/space_to_batch_nd_populate.cc +++ b/mindspore/lite/src/ops/populate/space_to_batch_nd_populate.cc @@ -19,42 +19,45 @@ using mindspore::schema::PrimitiveType_SpaceToBatchND; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateSpaceToBatchNDParameter(const void *prim) { - auto *space_batch_param_nd = reinterpret_cast(malloc(sizeof(SpaceToBatchParameter))); - if (space_batch_param_nd == nullptr) { - MS_LOG(ERROR) << "malloc SpaceToBatchParameter failed."; - return nullptr; - } - memset(space_batch_param_nd, 0, sizeof(SpaceToBatchParameter)); auto *primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - space_batch_param_nd->op_parameter_.type_ = primitive->value_type(); - auto param = primitive->value_as_SpaceToBatchND(); + auto value = primitive->value_as_SpaceToBatchND(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } + + auto *param = reinterpret_cast(malloc(sizeof(SpaceToBatchParameter))); if (param == nullptr) { - MS_LOG(ERROR) << "param is nullptr"; + MS_LOG(ERROR) << "malloc SpaceToBatchParameter failed."; return nullptr; } - auto block_shape = param->block_shape(); + memset(param, 0, sizeof(SpaceToBatchParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + auto block_shape = value->block_shape(); if (block_shape == nullptr) { - return reinterpret_cast(space_batch_param_nd); + return reinterpret_cast(param); } auto block_shapes = std::vector(block_shape->begin(), block_shape->end()); if (block_shapes.size() > std::numeric_limits::max() / sizeof(int)) { MS_LOG(ERROR) << "The value of block_shapes.size() is too big"; - free(space_batch_param_nd); + free(param); return nullptr; } - space_batch_param_nd->m_ = block_shapes.size(); + param->m_ = block_shapes.size(); - auto param_paddings = param->paddings(); + auto param_paddings = value->paddings(); if (param_paddings == nullptr) { MS_LOG(ERROR) << "param_paddings is nullptr"; + free(param); return nullptr; } auto fb_paddings = param_paddings->data(); if (fb_paddings == nullptr) { MS_LOG(ERROR) << "fb_paddings is nullptr"; + free(param); return nullptr; } if (fb_paddings->size() == 0 || @@ -62,14 +65,15 @@ OpParameter *PopulateSpaceToBatchNDParameter(const void *prim) { static_cast(fb_paddings->size() * (*(fb_paddings->begin()))->data()->size()) > std::numeric_limits::max() / sizeof(int64_t))) { MS_LOG(ERROR) << "The value of paddings.size() is zero or too big"; - free(space_batch_param_nd); + free(param); return nullptr; } std::vector paddings; - for (auto iter = fb_paddings->begin(); iter != fb_paddings->end(); ++iter) { - auto paddings_data = (*iter)->data(); + for (auto fb_padding : *fb_paddings) { + auto paddings_data = fb_padding->data(); if (paddings_data == nullptr) { MS_LOG(ERROR) << "paddings_data is nullptr"; + free(param); return nullptr; } auto paddings_vec = std::vector(paddings_data->begin(), paddings_data->end()); @@ -77,17 +81,16 @@ OpParameter *PopulateSpaceToBatchNDParameter(const void *prim) { } for (size_t i = 0; i < block_shapes.size(); ++i) { - space_batch_param_nd->block_sizes_[i] = static_cast(block_shapes[i]); + param->block_sizes_[i] = static_cast(block_shapes[i]); } - - space_batch_param_nd->m_ = block_shapes.size(); + param->m_ = block_shapes.size(); for (size_t i = 0; i < paddings.size(); ++i) { - space_batch_param_nd->paddings_[i] = static_cast(paddings[i]); + param->paddings_[i] = static_cast(paddings[i]); } - return reinterpret_cast(space_batch_param_nd); + return reinterpret_cast(param); } -} // namespace + REG_POPULATE(PrimitiveType_SpaceToBatchND, PopulateSpaceToBatchNDParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/space_to_batch_populate.cc b/mindspore/lite/src/ops/populate/space_to_batch_populate.cc index 42e294126d..fdec236f0e 100644 --- a/mindspore/lite/src/ops/populate/space_to_batch_populate.cc +++ b/mindspore/lite/src/ops/populate/space_to_batch_populate.cc @@ -19,43 +19,47 @@ using mindspore::schema::PrimitiveType_SpaceToBatch; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateSpaceToBatchParameter(const void *prim) { - auto *space_batch_param = reinterpret_cast(malloc(sizeof(SpaceToBatchParameter))); - if (space_batch_param == nullptr) { - MS_LOG(ERROR) << "malloc SpaceToBatchParameter failed."; - return nullptr; - } - memset(space_batch_param, 0, sizeof(SpaceToBatchParameter)); auto *primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - space_batch_param->op_parameter_.type_ = primitive->value_type(); - auto param = primitive->value_as_SpaceToBatch(); - if (param == nullptr) { + auto value = primitive->value_as_SpaceToBatch(); + if (value == nullptr) { MS_LOG(ERROR) << "param is nullptr"; return nullptr; } - auto block_size = param->block_size(); + + auto *param = reinterpret_cast(malloc(sizeof(SpaceToBatchParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc SpaceToBatchParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(SpaceToBatchParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + auto block_size = value->block_size(); if (block_size == nullptr) { MS_LOG(ERROR) << "block_size is nullptr"; + free(param); return nullptr; } auto block_sizes = std::vector(block_size->begin(), block_size->end()); if (block_sizes.size() > std::numeric_limits::max() / sizeof(int)) { MS_LOG(ERROR) << "The value of block_sizes.size() is too big"; - free(space_batch_param); + free(param); return nullptr; } - space_batch_param->m_ = block_sizes.size(); + param->m_ = block_sizes.size(); - auto param_paddings = param->paddings(); + auto param_paddings = value->paddings(); if (param_paddings == nullptr) { MS_LOG(ERROR) << "param_paddings is nullptr"; + free(param); return nullptr; } auto fb_paddings = param_paddings->data(); if (fb_paddings == nullptr) { MS_LOG(ERROR) << "fb_paddings is nullptr"; + free(param); return nullptr; } if (fb_paddings->size() == 0 || @@ -63,14 +67,15 @@ OpParameter *PopulateSpaceToBatchParameter(const void *prim) { static_cast(fb_paddings->size() * (*(fb_paddings->begin()))->data()->size()) > std::numeric_limits::max() / sizeof(int64_t))) { MS_LOG(ERROR) << "The value of paddings.size() is zero or too big"; - free(space_batch_param); + free(param); return nullptr; } std::vector paddings; - for (auto iter = fb_paddings->begin(); iter != fb_paddings->end(); ++iter) { - auto paddings_data = (*iter)->data(); + for (auto fb_padding : *fb_paddings) { + auto paddings_data = fb_padding->data(); if (paddings_data == nullptr) { MS_LOG(ERROR) << "paddings_data is nullptr"; + free(param); return nullptr; } auto paddings_vec = std::vector(paddings_data->begin(), paddings_data->end()); @@ -78,15 +83,15 @@ OpParameter *PopulateSpaceToBatchParameter(const void *prim) { } for (size_t i = 0; i < block_sizes.size(); ++i) { - space_batch_param->block_sizes_[i] = static_cast(block_sizes[i]); + param->block_sizes_[i] = static_cast(block_sizes[i]); } for (size_t i = 0; i < paddings.size(); ++i) { - space_batch_param->paddings_[i] = static_cast(paddings[i]); + param->paddings_[i] = static_cast(paddings[i]); } - return reinterpret_cast(space_batch_param); + return reinterpret_cast(param); } -} // namespace + REG_POPULATE(PrimitiveType_SpaceToBatch, PopulateSpaceToBatchParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/space_to_depth_populate.cc b/mindspore/lite/src/ops/populate/space_to_depth_populate.cc index b673e381d6..a2e1382e83 100644 --- a/mindspore/lite/src/ops/populate/space_to_depth_populate.cc +++ b/mindspore/lite/src/ops/populate/space_to_depth_populate.cc @@ -20,12 +20,6 @@ using mindspore::schema::PrimitiveType_SpaceToDepth; namespace mindspore { namespace lite { OpParameter *PopulateSpaceToDepthParameter(const void *prim) { - auto *space_depth_param = reinterpret_cast(malloc(sizeof(SpaceToDepthParameter))); - if (space_depth_param == nullptr) { - MS_LOG(ERROR) << "malloc SpaceToDepthParameter failed."; - return nullptr; - } - memset(space_depth_param, 0, sizeof(SpaceToDepthParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_SpaceToDepth(); @@ -33,15 +27,24 @@ OpParameter *PopulateSpaceToDepthParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - space_depth_param->op_parameter_.type_ = primitive->value_type(); - space_depth_param->block_size_ = value->block_size(); + + auto *param = reinterpret_cast(malloc(sizeof(SpaceToDepthParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc SpaceToDepthParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(SpaceToDepthParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->block_size_ = value->block_size(); if (value->format() != schema::Format::Format_NHWC) { MS_LOG(ERROR) << "Currently only NHWC format is supported."; - free(space_depth_param); + free(param); return nullptr; } - return reinterpret_cast(space_depth_param); + return reinterpret_cast(param); } + REG_POPULATE(PrimitiveType_SpaceToDepth, PopulateSpaceToDepthParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/sparse_softmax_cross_entropy_with_logits.cc b/mindspore/lite/src/ops/populate/sparse_softmax_cross_entropy_with_logits.cc index 6c6ff16fe5..375b97908a 100644 --- a/mindspore/lite/src/ops/populate/sparse_softmax_cross_entropy_with_logits.cc +++ b/mindspore/lite/src/ops/populate/sparse_softmax_cross_entropy_with_logits.cc @@ -20,18 +20,20 @@ using mindspore::schema::PrimitiveType_SparseSoftmaxCrossEntropyWithLogits; namespace mindspore { namespace lite { OpParameter *PopulateSparseSoftmaxCrossEntropyWithLogitsParameter(const void *prim) { - auto *softmax_cross_entropy_param_ = - reinterpret_cast(malloc(sizeof(SoftmaxCrossEntropyParameter))); - if (softmax_cross_entropy_param_ == nullptr) { + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + + auto *param = reinterpret_cast(malloc(sizeof(SoftmaxCrossEntropyParameter))); + if (param == nullptr) { MS_LOG(ERROR) << "malloc SoftmaxCrossEntropyParameter failed."; return nullptr; } - memset(softmax_cross_entropy_param_, 0, sizeof(SoftmaxCrossEntropyParameter)); - auto primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); - softmax_cross_entropy_param_->op_parameter_.type_ = primitive->value_type(); - return reinterpret_cast(softmax_cross_entropy_param_); + memset(param, 0, sizeof(SoftmaxCrossEntropyParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + return reinterpret_cast(param); } + REG_POPULATE(PrimitiveType_SparseSoftmaxCrossEntropyWithLogits, PopulateSparseSoftmaxCrossEntropyWithLogitsParameter, SCHEMA_CUR); } // namespace lite diff --git a/mindspore/lite/src/ops/populate/sparse_to_dense_populate.cc b/mindspore/lite/src/ops/populate/sparse_to_dense_populate.cc index 45ecb2a92d..50755feb49 100644 --- a/mindspore/lite/src/ops/populate/sparse_to_dense_populate.cc +++ b/mindspore/lite/src/ops/populate/sparse_to_dense_populate.cc @@ -19,20 +19,20 @@ using mindspore::schema::PrimitiveType_SparseToDense; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateSparseToDenseParameter(const void *prim) { - auto *sparse_to_dense_param = reinterpret_cast(malloc(sizeof(SparseToDenseParameter))); - if (sparse_to_dense_param == nullptr) { + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + + auto *param = reinterpret_cast(malloc(sizeof(SparseToDenseParameter))); + if (param == nullptr) { MS_LOG(ERROR) << "malloc SparseToDenseParameter failed."; return nullptr; } - memset(sparse_to_dense_param, 0, sizeof(SparseToDenseParameter)); - auto primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); - sparse_to_dense_param->op_parameter_.type_ = primitive->value_type(); - return reinterpret_cast(sparse_to_dense_param); + memset(param, 0, sizeof(SparseToDenseParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_SparseToDense, PopulateSparseToDenseParameter, SCHEMA_CUR); } // namespace lite diff --git a/mindspore/lite/src/ops/populate/splice_populate.cc b/mindspore/lite/src/ops/populate/splice_populate.cc index 8e5a618970..9cc6c6579c 100644 --- a/mindspore/lite/src/ops/populate/splice_populate.cc +++ b/mindspore/lite/src/ops/populate/splice_populate.cc @@ -17,71 +17,75 @@ #include "nnacl/op_base.h" #include "nnacl/splice_parameter.h" using mindspore::schema::PrimitiveType_Splice; + namespace mindspore { namespace lite { OpParameter *PopulateSpliceParameter(const void *prim) { - auto *splice_parameter = reinterpret_cast(malloc(sizeof(SpliceParameter))); - if (splice_parameter == nullptr) { - MS_LOG(ERROR) << "malloc Splice Parameter failed."; - return nullptr; - } - memset(splice_parameter, 0, sizeof(SpliceParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - auto splice_primitive = primitive->value_as_Splice(); - if (splice_primitive == nullptr) { - MS_LOG(ERROR) << "splice_primitive is nullptr"; + auto value = primitive->value_as_Splice(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - splice_parameter->op_parameter_.type_ = primitive->value_type(); - auto context = splice_primitive->context(); + auto *param = reinterpret_cast(malloc(sizeof(SpliceParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc Splice Parameter failed."; + return nullptr; + } + memset(param, 0, sizeof(SpliceParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + auto context = value->context(); if (context == nullptr) { MS_LOG(ERROR) << "context is nullptr"; + free(param); return nullptr; } std::vector primitive_context(context->begin(), context->end()); - splice_parameter->context_dim_ = static_cast(primitive_context.size()); + param->context_dim_ = static_cast(primitive_context.size()); // malloc && memset for context - splice_parameter->context_ = reinterpret_cast(malloc(splice_parameter->context_dim_ * sizeof(int))); - if (splice_parameter->context_ == nullptr) { - MS_LOG(ERROR) << "malloc splice_parameter context_ error"; - free(splice_parameter); + param->context_ = reinterpret_cast(malloc(param->context_dim_ * sizeof(int))); + if (param->context_ == nullptr) { + MS_LOG(ERROR) << "malloc param context_ error"; + free(param); return nullptr; } // src_to_dst_row_offset int src_to_dst_row_offset = INT32_MIN; - memset(splice_parameter->context_, 0, splice_parameter->context_dim_ * sizeof(int)); - for (int i = 0; i < splice_parameter->context_dim_; ++i) { - splice_parameter->context_[i] = primitive_context.at(i); + memset(param->context_, 0, param->context_dim_ * sizeof(int)); + for (int i = 0; i < param->context_dim_; ++i) { + param->context_[i] = primitive_context.at(i); src_to_dst_row_offset = std::max(src_to_dst_row_offset, std::abs(primitive_context.at(i))); } - auto forward_indexes = splice_primitive->forward_indexes(); + auto forward_indexes = value->forward_indexes(); if (forward_indexes == nullptr) { MS_LOG(ERROR) << "forward_indexes is nullptr"; + free(param); return nullptr; } std::vector primitive_forward_indexes(forward_indexes->begin(), forward_indexes->end()); - splice_parameter->forward_indexes_dim_ = static_cast(primitive_forward_indexes.size()); + param->forward_indexes_dim_ = static_cast(primitive_forward_indexes.size()); // malloc && memset for forward_indexes - splice_parameter->forward_indexes_ = - reinterpret_cast(malloc(splice_parameter->forward_indexes_dim_ * sizeof(int))); - if (splice_parameter->forward_indexes_ == nullptr) { - MS_LOG(ERROR) << "malloc splice_parameter forward_indexes_ error"; - free(splice_parameter->context_); - free(splice_parameter); + param->forward_indexes_ = reinterpret_cast(malloc(param->forward_indexes_dim_ * sizeof(int))); + if (param->forward_indexes_ == nullptr) { + MS_LOG(ERROR) << "malloc param forward_indexes_ error"; + free(param->context_); + free(param); return nullptr; } - memset(splice_parameter->forward_indexes_, 0, splice_parameter->forward_indexes_dim_ * sizeof(int)); - for (int i = 0; i < splice_parameter->context_dim_; ++i) { - splice_parameter->context_[i] = primitive_context.at(i); + memset(param->forward_indexes_, 0, param->forward_indexes_dim_ * sizeof(int)); + for (int i = 0; i < param->context_dim_; ++i) { + param->context_[i] = primitive_context.at(i); } - splice_parameter->output_dim_ = splice_primitive->output_dim(); - return reinterpret_cast(splice_parameter); + param->output_dim_ = value->output_dim(); + return reinterpret_cast(param); } + REG_POPULATE(PrimitiveType_Splice, PopulateSpliceParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/split_populate.cc b/mindspore/lite/src/ops/populate/split_populate.cc index a855987468..8f538f6ad4 100644 --- a/mindspore/lite/src/ops/populate/split_populate.cc +++ b/mindspore/lite/src/ops/populate/split_populate.cc @@ -19,15 +19,7 @@ using mindspore::schema::PrimitiveType_Split; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateSplitParameter(const void *prim) { - auto *split_param = reinterpret_cast(malloc(sizeof(SplitParameter))); - if (split_param == nullptr) { - MS_LOG(ERROR) << "malloc SplitParameter failed."; - return nullptr; - } - memset(split_param, 0, sizeof(SplitParameter)); - auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_Split(); @@ -35,36 +27,44 @@ OpParameter *PopulateSplitParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - split_param->op_parameter_.type_ = primitive->value_type(); - split_param->num_split_ = value->output_num(); - if (split_param->num_split_ > std::numeric_limits::max() / static_cast(sizeof(int))) { - MS_LOG(ERROR) << "The value of split_param->num_split_ is too big"; - free(split_param); + + auto *param = reinterpret_cast(malloc(sizeof(SplitParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc SplitParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(SplitParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->num_split_ = value->output_num(); + if (param->num_split_ > std::numeric_limits::max() / static_cast(sizeof(int))) { + MS_LOG(ERROR) << "The value of param->num_split_ is too big"; + free(param); return nullptr; } /* free split_sizes_ in split op base */ - split_param->split_sizes_ = reinterpret_cast(malloc(split_param->num_split_ * sizeof(int))); - if (split_param->split_sizes_ == nullptr) { - MS_LOG(ERROR) << "malloc split_param split_sizes_ error"; - free(split_param); + param->split_sizes_ = reinterpret_cast(malloc(param->num_split_ * sizeof(int))); + if (param->split_sizes_ == nullptr) { + MS_LOG(ERROR) << "malloc param split_sizes_ error"; + free(param); return nullptr; } - memset(split_param->split_sizes_, 0, split_param->num_split_ * sizeof(int)); + memset(param->split_sizes_, 0, param->num_split_ * sizeof(int)); auto split_sizes_vector_ = value->size_splits(); if (split_sizes_vector_ != nullptr) { int i = 0; for (auto iter : *split_sizes_vector_) { - split_param->split_sizes_[i++] = iter; + param->split_sizes_[i++] = iter; } - split_param->split_count_ = split_param->num_split_; + param->split_count_ = param->num_split_; } else { - split_param->split_count_ = 0; + param->split_count_ = 0; } - split_param->split_dim_ = value->axis(); - return reinterpret_cast(split_param); + param->split_dim_ = value->axis(); + return reinterpret_cast(param); } -} // namespace + REG_POPULATE(PrimitiveType_Split, PopulateSplitParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/split_with_overlap_populate.cc b/mindspore/lite/src/ops/populate/split_with_overlap_populate.cc index fa5f390dcb..4825732877 100644 --- a/mindspore/lite/src/ops/populate/split_with_overlap_populate.cc +++ b/mindspore/lite/src/ops/populate/split_with_overlap_populate.cc @@ -20,48 +20,57 @@ using mindspore::schema::PrimitiveType_SplitWithOverlap; namespace mindspore { namespace lite { OpParameter *PopulateSplitWithOverlapParameter(const void *prim) { - auto *split_with_over_lap_param = - reinterpret_cast(malloc(sizeof(SplitWithOverlapParameter))); - if (split_with_over_lap_param == nullptr) { - MS_LOG(ERROR) << "malloc PopulateSplitWithOverlapParameter failed."; + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + auto value = primitive->value_as_SplitWithOverlap(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - memset(split_with_over_lap_param, 0, sizeof(SplitWithOverlapParameter)); - auto primitive = static_cast(prim); - auto value = primitive->value_as_SplitWithOverlap(); - split_with_over_lap_param->op_parameter_.type_ = primitive->value_type(); + auto *param = reinterpret_cast(malloc(sizeof(SplitWithOverlapParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc PopulateSplitWithOverlapParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(SplitWithOverlapParameter)); + param->op_parameter_.type_ = primitive->value_type(); auto ratio = value->ratio(); + if (ratio == nullptr) { + MS_LOG(ERROR) << "ratio is nullptr"; + free(param); + return nullptr; + } if (ratio->size() > SPLIT_MAX_SLICE_NUM) { MS_LOG(ERROR) << "SplitWithOverlap do not support splitting tensor into more than " << SPLIT_MAX_SLICE_NUM << " slices"; - delete split_with_over_lap_param; + free(param); return nullptr; } - - split_with_over_lap_param->num_split_ = static_cast(ratio->size()); - split_with_over_lap_param->split_dim_ = value->split_dim(); + param->num_split_ = static_cast(ratio->size()); + param->split_dim_ = value->split_dim(); auto extend_top = value->extend_top(); auto extend_bottom = value->extend_bottom(); - if (extend_top->size() != ratio->size() || extend_bottom->size() != ratio->size()) { + if (extend_top->size() != ratio->size() || (extend_bottom != nullptr && extend_bottom->size() != ratio->size())) { MS_LOG(ERROR) << "The sizes of ratio, extend_top and extend_bottom are not identical"; - delete split_with_over_lap_param; + free(param); return nullptr; } for (size_t i = 0; i < ratio->size(); ++i) { - split_with_over_lap_param->ratio_[i] = (*ratio)[i]; - split_with_over_lap_param->extend_top_[i] = (*extend_top)[i]; - split_with_over_lap_param->extend_bottom_[i] = (*extend_bottom)[i]; + param->ratio_[i] = (*ratio)[i]; + param->extend_top_[i] = (*extend_top)[i]; + param->extend_bottom_[i] = (*extend_bottom)[i]; } - split_with_over_lap_param->stride_ = value->stride(); - split_with_over_lap_param->pad_top_ = value->pad_top(); + param->stride_ = value->stride(); + param->pad_top_ = value->pad_top(); - return reinterpret_cast(split_with_over_lap_param); + return reinterpret_cast(param); } + REG_POPULATE(PrimitiveType_SplitWithOverlap, PopulateSplitWithOverlapParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/squeeze_populate.cc b/mindspore/lite/src/ops/populate/squeeze_populate.cc index 88edfb311b..a2c0f49110 100644 --- a/mindspore/lite/src/ops/populate/squeeze_populate.cc +++ b/mindspore/lite/src/ops/populate/squeeze_populate.cc @@ -19,36 +19,35 @@ using mindspore::schema::PrimitiveType_Squeeze; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateSqueezeParameter(const void *prim) { - SqueezeParameter *squeeze_param = reinterpret_cast(malloc(sizeof(SqueezeParameter))); - if (squeeze_param == nullptr) { - MS_LOG(ERROR) << "malloc SqueezeParameter failed."; - return nullptr; - } - memset(squeeze_param, 0, sizeof(SqueezeParameter)); auto *primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - squeeze_param->op_parameter_.type_ = primitive->value_type(); + auto value = primitive->value_as_Squeeze(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } - auto squeeze_prim = primitive->value_as_Squeeze(); - if (squeeze_prim == nullptr) { - MS_LOG(ERROR) << "squeeze_prim is nullptr"; + auto *param = reinterpret_cast(malloc(sizeof(SqueezeParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc SqueezeParameter failed."; return nullptr; } - auto axis = squeeze_prim->axis(); - if (squeeze_prim->axis() != nullptr) { - squeeze_param->axis_size_ = axis->size(); - for (size_t i = 0; i < squeeze_param->axis_size_; i++) { - squeeze_param->axis_[i] = *(axis->begin() + i); + memset(param, 0, sizeof(SqueezeParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + auto axis = value->axis(); + if (axis != nullptr) { + param->axis_size_ = axis->size(); + for (size_t i = 0; i < param->axis_size_; i++) { + param->axis_[i] = *(axis->begin() + i); } } else { - squeeze_param->axis_size_ = 0; + param->axis_size_ = 0; } - - return reinterpret_cast(squeeze_param); + return reinterpret_cast(param); } -} // namespace + REG_POPULATE(PrimitiveType_Squeeze, PopulateSqueezeParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/stack_populate.cc b/mindspore/lite/src/ops/populate/stack_populate.cc index 96876e460d..af26ac24d0 100644 --- a/mindspore/lite/src/ops/populate/stack_populate.cc +++ b/mindspore/lite/src/ops/populate/stack_populate.cc @@ -19,14 +19,7 @@ using mindspore::schema::PrimitiveType_Stack; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateStackParameter(const void *prim) { - auto *stack_param = reinterpret_cast(malloc(sizeof(StackParameter))); - if (stack_param == nullptr) { - MS_LOG(ERROR) << "malloc StackParameter failed."; - return nullptr; - } - memset(stack_param, 0, sizeof(StackParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_Stack(); @@ -34,11 +27,19 @@ OpParameter *PopulateStackParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - stack_param->op_parameter_.type_ = primitive->value_type(); - stack_param->axis_ = static_cast(value->axis()); - return reinterpret_cast(stack_param); + + auto *param = reinterpret_cast(malloc(sizeof(StackParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc StackParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(StackParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->axis_ = static_cast(value->axis()); + return reinterpret_cast(param); } -} // namespace + REG_POPULATE(PrimitiveType_Stack, PopulateStackParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/strided_slice_grad_populate.cc b/mindspore/lite/src/ops/populate/strided_slice_grad_populate.cc index 8e2cf7cc4b..d899d1ec89 100644 --- a/mindspore/lite/src/ops/populate/strided_slice_grad_populate.cc +++ b/mindspore/lite/src/ops/populate/strided_slice_grad_populate.cc @@ -20,13 +20,6 @@ using mindspore::schema::PrimitiveType_StridedSliceGrad; namespace mindspore { namespace lite { OpParameter *PopulateStridedSliceGradParameter(const void *prim) { - auto *strided_slice_param = reinterpret_cast(malloc(sizeof(StridedSliceParameter))); - if (strided_slice_param == nullptr) { - MS_LOG(ERROR) << "malloc StridedSliceParameter failed."; - return nullptr; - } - memset(strided_slice_param, 0, sizeof(StridedSliceParameter)); - auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_StridedSliceGrad(); @@ -34,17 +27,23 @@ OpParameter *PopulateStridedSliceGradParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - strided_slice_param->op_parameter_.type_ = primitive->value_type(); - strided_slice_param->begins_mask_ = value->begin_mask(); - strided_slice_param->ends_mask_ = value->end_mask(); - strided_slice_param->ellipsisMask_ = value->ellipsis_mask(); - strided_slice_param->newAxisMask_ = value->new_axis_mask(); - strided_slice_param->shrinkAxisMask_ = value->shrink_axis_mask(); - return reinterpret_cast(strided_slice_param); + auto *param = reinterpret_cast(malloc(sizeof(StridedSliceParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc StridedSliceParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(StridedSliceParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->begins_mask_ = value->begin_mask(); + param->ends_mask_ = value->end_mask(); + param->ellipsisMask_ = value->ellipsis_mask(); + param->newAxisMask_ = value->new_axis_mask(); + param->shrinkAxisMask_ = value->shrink_axis_mask(); + return reinterpret_cast(param); } REG_POPULATE(PrimitiveType_StridedSliceGrad, PopulateStridedSliceGradParameter, SCHEMA_CUR); - } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/strided_slice_populate.cc b/mindspore/lite/src/ops/populate/strided_slice_populate.cc index 0ebb36fcc0..e5892c47eb 100644 --- a/mindspore/lite/src/ops/populate/strided_slice_populate.cc +++ b/mindspore/lite/src/ops/populate/strided_slice_populate.cc @@ -19,13 +19,6 @@ using mindspore::schema::PrimitiveType_StridedSlice; namespace mindspore { namespace lite { OpParameter *PopulateStridedSliceParameter(const void *prim) { - auto *strided_slice_param = reinterpret_cast(malloc(sizeof(StridedSliceParameter))); - if (strided_slice_param == nullptr) { - MS_LOG(ERROR) << "malloc StridedSliceParameter failed."; - return nullptr; - } - memset(strided_slice_param, 0, sizeof(StridedSliceParameter)); - auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_StridedSlice(); @@ -33,14 +26,21 @@ OpParameter *PopulateStridedSliceParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - strided_slice_param->op_parameter_.type_ = primitive->value_type(); - strided_slice_param->begins_mask_ = value->begin_mask(); - strided_slice_param->ends_mask_ = value->end_mask(); - strided_slice_param->ellipsisMask_ = value->ellipsis_mask(); - strided_slice_param->newAxisMask_ = value->new_axis_mask(); - strided_slice_param->shrinkAxisMask_ = value->shrink_axis_mask(); - return reinterpret_cast(strided_slice_param); + auto *param = reinterpret_cast(malloc(sizeof(StridedSliceParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc StridedSliceParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(StridedSliceParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->begins_mask_ = value->begin_mask(); + param->ends_mask_ = value->end_mask(); + param->ellipsisMask_ = value->ellipsis_mask(); + param->newAxisMask_ = value->new_axis_mask(); + param->shrinkAxisMask_ = value->shrink_axis_mask(); + return reinterpret_cast(param); } REG_POPULATE(PrimitiveType_StridedSlice, PopulateStridedSliceParameter, SCHEMA_CUR) diff --git a/mindspore/lite/src/ops/populate/sub_populate.cc b/mindspore/lite/src/ops/populate/sub_populate.cc index 92e9ef3c69..4dddaa3e88 100644 --- a/mindspore/lite/src/ops/populate/sub_populate.cc +++ b/mindspore/lite/src/ops/populate/sub_populate.cc @@ -21,13 +21,15 @@ using mindspore::schema::PrimitiveType_SubFusion; namespace mindspore { namespace lite { OpParameter *PopulateSubParameter(const void *prim) { + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + ArithmeticParameter *param = PopulateArithmeticCommonPara(prim); if (param == nullptr) { - MS_LOG(ERROR) << "PopulateArithmeticCommonPara failed."; + MS_LOG(ERROR) << "get PopulateArithmeticCommonPara failed."; return nullptr; } - auto primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); + param->op_parameter_.type_ = primitive->value_type(); return reinterpret_cast(param); } diff --git a/mindspore/lite/src/ops/populate/switch_populate.cc b/mindspore/lite/src/ops/populate/switch_populate.cc index c3ba0208ed..4a8673287f 100644 --- a/mindspore/lite/src/ops/populate/switch_populate.cc +++ b/mindspore/lite/src/ops/populate/switch_populate.cc @@ -19,18 +19,20 @@ using mindspore::schema::PrimitiveType_Switch; namespace mindspore { namespace lite { OpParameter *PopulateSwitchParameter(const void *prim) { - auto *switch_parameter = reinterpret_cast(malloc(sizeof(OpParameter))); - if (switch_parameter == nullptr) { - MS_LOG(ERROR) << "malloc SwitchParameter failed."; - return nullptr; - } - memset(switch_parameter, 0, sizeof(OpParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - switch_parameter->type_ = primitive->value_type(); - return reinterpret_cast(switch_parameter); + auto *param = reinterpret_cast(malloc(sizeof(OpParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc OpParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(OpParameter)); + + param->type_ = primitive->value_type(); + return reinterpret_cast(param); } + REG_POPULATE(PrimitiveType_Switch, PopulateSwitchParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/tensorlistfromtensor_populate.cc b/mindspore/lite/src/ops/populate/tensorlistfromtensor_populate.cc index ccbf5cdfa9..7d5a388e44 100644 --- a/mindspore/lite/src/ops/populate/tensorlistfromtensor_populate.cc +++ b/mindspore/lite/src/ops/populate/tensorlistfromtensor_populate.cc @@ -21,12 +21,6 @@ using mindspore::schema::PrimitiveType_TensorListFromTensor; namespace mindspore { namespace lite { OpParameter *PopulateTensorListFromTensorParameter(const void *prim) { - auto *TensorList_param = reinterpret_cast(malloc(sizeof(TensorListParameter))); - if (TensorList_param == nullptr) { - MS_LOG(ERROR) << "malloc TensorListParameter failed."; - return nullptr; - } - memset(TensorList_param, 0, sizeof(TensorListParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_TensorListFromTensor(); @@ -34,12 +28,20 @@ OpParameter *PopulateTensorListFromTensorParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - TensorList_param->op_parameter_.type_ = primitive->value_type(); - TensorList_param->shape_type_ = value->shape_type(); - TensorList_param->element_dtype_ = value->element_dtype(); - return reinterpret_cast(TensorList_param); + + auto *param = reinterpret_cast(malloc(sizeof(TensorListParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc TensorListParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(TensorListParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->shape_type_ = value->shape_type(); + param->element_dtype_ = value->element_dtype(); + return reinterpret_cast(param); } -REG_POPULATE(PrimitiveType_TensorListFromTensor, PopulateTensorListFromTensorParameter, SCHEMA_CUR); +REG_POPULATE(PrimitiveType_TensorListFromTensor, PopulateTensorListFromTensorParameter, SCHEMA_CUR); } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/tensorlistgetitem_populate.cc b/mindspore/lite/src/ops/populate/tensorlistgetitem_populate.cc index fcbb4646ba..197aefe507 100644 --- a/mindspore/lite/src/ops/populate/tensorlistgetitem_populate.cc +++ b/mindspore/lite/src/ops/populate/tensorlistgetitem_populate.cc @@ -20,12 +20,6 @@ using mindspore::schema::PrimitiveType_TensorListGetItem; namespace mindspore { namespace lite { OpParameter *PopulateTensorListGetItemParameter(const void *prim) { - auto *getItem_param = reinterpret_cast(malloc(sizeof(TensorListParameter))); - if (getItem_param == nullptr) { - MS_LOG(ERROR) << "malloc TensorListParameter failed."; - return nullptr; - } - memset(getItem_param, 0, sizeof(TensorListParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_TensorListGetItem(); @@ -33,11 +27,19 @@ OpParameter *PopulateTensorListGetItemParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - getItem_param->op_parameter_.type_ = primitive->value_type(); - getItem_param->element_dtype_ = value->element_dtype(); - return reinterpret_cast(getItem_param); + + auto *param = reinterpret_cast(malloc(sizeof(TensorListParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc TensorListParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(TensorListParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->element_dtype_ = value->element_dtype(); + return reinterpret_cast(param); } -REG_POPULATE(PrimitiveType_TensorListGetItem, PopulateTensorListGetItemParameter, SCHEMA_CUR); +REG_POPULATE(PrimitiveType_TensorListGetItem, PopulateTensorListGetItemParameter, SCHEMA_CUR); } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/tensorlistreserve_populate.cc b/mindspore/lite/src/ops/populate/tensorlistreserve_populate.cc index e0d9244e7f..57065865c8 100644 --- a/mindspore/lite/src/ops/populate/tensorlistreserve_populate.cc +++ b/mindspore/lite/src/ops/populate/tensorlistreserve_populate.cc @@ -20,12 +20,6 @@ using mindspore::schema::PrimitiveType_TensorListReserve; namespace mindspore { namespace lite { OpParameter *PopulateTensorListReserveParameter(const void *prim) { - auto *reserve_param = reinterpret_cast(malloc(sizeof(TensorListParameter))); - if (reserve_param == nullptr) { - MS_LOG(ERROR) << "malloc TensorListParameter failed."; - return nullptr; - } - memset(reserve_param, 0, sizeof(TensorListParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_TensorListReserve(); @@ -33,11 +27,19 @@ OpParameter *PopulateTensorListReserveParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - reserve_param->op_parameter_.type_ = primitive->value_type(); - reserve_param->element_dtype_ = value->element_dtype(); - return reinterpret_cast(reserve_param); + + auto *param = reinterpret_cast(malloc(sizeof(TensorListParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc TensorListParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(TensorListParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->element_dtype_ = value->element_dtype(); + return reinterpret_cast(param); } -REG_POPULATE(PrimitiveType_TensorListReserve, PopulateTensorListReserveParameter, SCHEMA_CUR); +REG_POPULATE(PrimitiveType_TensorListReserve, PopulateTensorListReserveParameter, SCHEMA_CUR); } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/tensorlistsetlitem_populate.cc b/mindspore/lite/src/ops/populate/tensorlistsetlitem_populate.cc index d14f32ab1a..c3a802d651 100644 --- a/mindspore/lite/src/ops/populate/tensorlistsetlitem_populate.cc +++ b/mindspore/lite/src/ops/populate/tensorlistsetlitem_populate.cc @@ -20,12 +20,6 @@ using mindspore::schema::PrimitiveType_TensorListSetItem; namespace mindspore { namespace lite { OpParameter *PopulateTensorListSetItemParameter(const void *prim) { - auto *setItem_param = reinterpret_cast(malloc(sizeof(TensorListParameter))); - if (setItem_param == nullptr) { - MS_LOG(ERROR) << "malloc TensorListParameter failed."; - return nullptr; - } - memset(setItem_param, 0, sizeof(TensorListParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_TensorListSetItem(); @@ -33,11 +27,19 @@ OpParameter *PopulateTensorListSetItemParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - setItem_param->op_parameter_.type_ = primitive->value_type(); - setItem_param->element_dtype_ = value->element_dtype(); - return reinterpret_cast(setItem_param); + + auto *param = reinterpret_cast(malloc(sizeof(TensorListParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc TensorListParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(TensorListParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->element_dtype_ = value->element_dtype(); + return reinterpret_cast(param); } -REG_POPULATE(PrimitiveType_TensorListSetItem, PopulateTensorListSetItemParameter, SCHEMA_CUR); +REG_POPULATE(PrimitiveType_TensorListSetItem, PopulateTensorListSetItemParameter, SCHEMA_CUR); } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/tensorliststack_populate.cc b/mindspore/lite/src/ops/populate/tensorliststack_populate.cc index 6eda2200c4..707622265b 100644 --- a/mindspore/lite/src/ops/populate/tensorliststack_populate.cc +++ b/mindspore/lite/src/ops/populate/tensorliststack_populate.cc @@ -20,12 +20,6 @@ using mindspore::schema::PrimitiveType_TensorListStack; namespace mindspore { namespace lite { OpParameter *PopulateTensorListStackParameter(const void *prim) { - auto *stack_param = reinterpret_cast(malloc(sizeof(TensorListParameter))); - if (stack_param == nullptr) { - MS_LOG(ERROR) << "malloc TensorListParameter failed."; - return nullptr; - } - memset(stack_param, 0, sizeof(TensorListParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_TensorListStack(); @@ -33,12 +27,20 @@ OpParameter *PopulateTensorListStackParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - stack_param->op_parameter_.type_ = primitive->value_type(); - stack_param->element_dtype_ = value->element_dtype(); - stack_param->num_element_ = value->num_elements(); - return reinterpret_cast(stack_param); + + auto *param = reinterpret_cast(malloc(sizeof(TensorListParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc TensorListParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(TensorListParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->element_dtype_ = value->element_dtype(); + param->num_element_ = value->num_elements(); + return reinterpret_cast(param); } -REG_POPULATE(PrimitiveType_TensorListStack, PopulateTensorListStackParameter, SCHEMA_CUR); +REG_POPULATE(PrimitiveType_TensorListStack, PopulateTensorListStackParameter, SCHEMA_CUR); } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/tile_populate.cc b/mindspore/lite/src/ops/populate/tile_populate.cc index a78f57252d..89d60f5d64 100644 --- a/mindspore/lite/src/ops/populate/tile_populate.cc +++ b/mindspore/lite/src/ops/populate/tile_populate.cc @@ -20,12 +20,6 @@ using mindspore::schema::PrimitiveType_TileFusion; namespace mindspore { namespace lite { OpParameter *PopulateTileParameter(const void *prim) { - auto *tile_param = reinterpret_cast(malloc(sizeof(TileParameter))); - if (tile_param == nullptr) { - MS_LOG(ERROR) << "malloc TileParameter failed."; - return nullptr; - } - memset(tile_param, 0, sizeof(TileParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_TileFusion(); @@ -33,15 +27,23 @@ OpParameter *PopulateTileParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - tile_param->op_parameter_.type_ = primitive->value_type(); + + auto *param = reinterpret_cast(malloc(sizeof(TileParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc TileParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(TileParameter)); + + param->op_parameter_.type_ = primitive->value_type(); auto dims = value->dims(); if (dims != nullptr) { for (size_t i = 0; i < dims->size(); ++i) { - tile_param->dims_[i] = static_cast(dims->Get(i)); + param->dims_[i] = static_cast(dims->Get(i)); } - tile_param->dims_size_ = dims->size(); + param->dims_size_ = dims->size(); } - return reinterpret_cast(tile_param); + return reinterpret_cast(param); } REG_POPULATE(PrimitiveType_TileFusion, PopulateTileParameter, SCHEMA_CUR) diff --git a/mindspore/lite/src/ops/populate/topk_populate.cc b/mindspore/lite/src/ops/populate/topk_populate.cc index d75b685c41..6a89e5106e 100644 --- a/mindspore/lite/src/ops/populate/topk_populate.cc +++ b/mindspore/lite/src/ops/populate/topk_populate.cc @@ -19,26 +19,27 @@ using mindspore::schema::PrimitiveType_TopKFusion; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateTopKParameter(const void *prim) { - auto *topk_param = reinterpret_cast(malloc(sizeof(TopkParameter))); - if (topk_param == nullptr) { - MS_LOG(ERROR) << "malloc TopkParameter failed."; - return nullptr; - } - memset(topk_param, 0, sizeof(TopkParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - topk_param->op_parameter_.type_ = primitive->value_type(); - auto param = primitive->value_as_TopKFusion(); + auto value = primitive->value_as_TopKFusion(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } + + auto *param = reinterpret_cast(malloc(sizeof(TopkParameter))); if (param == nullptr) { - MS_LOG(ERROR) << "param is nullptr"; + MS_LOG(ERROR) << "malloc TopkParameter failed."; return nullptr; } - topk_param->sorted_ = param->sorted(); - return reinterpret_cast(topk_param); + memset(param, 0, sizeof(TopkParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->sorted_ = value->sorted(); + return reinterpret_cast(param); } -} // namespace + REG_POPULATE(PrimitiveType_TopKFusion, PopulateTopKParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/transpose_populate.cc b/mindspore/lite/src/ops/populate/transpose_populate.cc index 5441599f57..bae779be5e 100644 --- a/mindspore/lite/src/ops/populate/transpose_populate.cc +++ b/mindspore/lite/src/ops/populate/transpose_populate.cc @@ -19,20 +19,20 @@ using mindspore::schema::PrimitiveType_Transpose; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateTransposeParameter(const void *prim) { - auto *transpose_param = reinterpret_cast(malloc(sizeof(TransposeParameter))); - if (transpose_param == nullptr) { + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + + auto *param = reinterpret_cast(malloc(sizeof(TransposeParameter))); + if (param == nullptr) { MS_LOG(ERROR) << "malloc TransposeParameter failed."; return nullptr; } - memset(transpose_param, 0, sizeof(TransposeParameter)); - auto primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); - transpose_param->op_parameter_.type_ = primitive->value_type(); - return reinterpret_cast(transpose_param); + memset(param, 0, sizeof(TransposeParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_Transpose, PopulateTransposeParameter, SCHEMA_CUR) } // namespace lite diff --git a/mindspore/lite/src/ops/populate/uniform_real_populate.cc b/mindspore/lite/src/ops/populate/uniform_real_populate.cc index d2731375b0..ae348aaaf4 100644 --- a/mindspore/lite/src/ops/populate/uniform_real_populate.cc +++ b/mindspore/lite/src/ops/populate/uniform_real_populate.cc @@ -21,23 +21,25 @@ using mindspore::schema::PrimitiveType_UniformReal; namespace mindspore { namespace lite { OpParameter *PopulateRandomStandardNormalParameter(const void *prim) { - auto *random_parameter = reinterpret_cast(malloc(sizeof(RandomParam))); - if (random_parameter == nullptr) { - MS_LOG(ERROR) << "malloc Random parameter failed."; - return nullptr; - } - memset(random_parameter, 0, sizeof(RandomParam)); auto *primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - random_parameter->op_parameter_.type_ = primitive->value_type(); - auto param = primitive->value_as_RandomStandardNormal(); + auto value = primitive->value_as_RandomStandardNormal(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } + + auto *param = reinterpret_cast(malloc(sizeof(RandomParam))); if (param == nullptr) { - MS_LOG(ERROR) << "param is nullptr"; + MS_LOG(ERROR) << "malloc RandomParam failed."; return nullptr; } - random_parameter->seed_ = param->seed(); - random_parameter->seed2_ = param->seed2(); - return reinterpret_cast(random_parameter); + memset(param, 0, sizeof(RandomParam)); + + param->op_parameter_.type_ = primitive->value_type(); + param->seed_ = value->seed(); + param->seed2_ = value->seed2(); + return reinterpret_cast(param); } REG_POPULATE(PrimitiveType_UniformReal, DefaultPopulateParameter, SCHEMA_CUR) diff --git a/mindspore/lite/src/ops/populate/unique_populate.cc b/mindspore/lite/src/ops/populate/unique_populate.cc index d9c332a463..b656fb9149 100644 --- a/mindspore/lite/src/ops/populate/unique_populate.cc +++ b/mindspore/lite/src/ops/populate/unique_populate.cc @@ -19,20 +19,20 @@ using mindspore::schema::PrimitiveType_Unique; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateUniqueParameter(const void *prim) { - auto *unique_param = reinterpret_cast(malloc(sizeof(UniqueParameter))); - if (unique_param == nullptr) { + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + + auto *param = reinterpret_cast(malloc(sizeof(UniqueParameter))); + if (param == nullptr) { MS_LOG(ERROR) << "malloc UniqueParameter failed."; return nullptr; } - memset(unique_param, 0, sizeof(UniqueParameter)); - auto primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); - unique_param->op_parameter_.type_ = primitive->value_type(); - return reinterpret_cast(unique_param); + memset(param, 0, sizeof(UniqueParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_Unique, PopulateUniqueParameter, SCHEMA_CUR) } // namespace lite diff --git a/mindspore/lite/src/ops/populate/unsorted_segment_sum_populate.cc b/mindspore/lite/src/ops/populate/unsorted_segment_sum_populate.cc index 6e71e7e442..327a59ddc8 100644 --- a/mindspore/lite/src/ops/populate/unsorted_segment_sum_populate.cc +++ b/mindspore/lite/src/ops/populate/unsorted_segment_sum_populate.cc @@ -19,16 +19,18 @@ using mindspore::schema::PrimitiveType_UnsortedSegmentSum; namespace mindspore { namespace lite { OpParameter *PopulateUnsortedSegmentSumParameter(const void *prim) { + auto primitive = static_cast(prim); + MS_ASSERT(primitive != nullptr); + auto *param = reinterpret_cast(malloc(sizeof(OpParameter))); if (param == nullptr) { MS_LOG(ERROR) << "malloc UnsortedSegmentSum Parameter failed."; return nullptr; } memset(param, 0, sizeof(OpParameter)); - auto primitive = static_cast(prim); - MS_ASSERT(primitive != nullptr); + param->type_ = primitive->value_type(); - return param; + return reinterpret_cast(param); } REG_POPULATE(PrimitiveType_UnsortedSegmentSum, PopulateUnsortedSegmentSumParameter, SCHEMA_CUR); diff --git a/mindspore/lite/src/ops/populate/unsqueeze_populate.cc b/mindspore/lite/src/ops/populate/unsqueeze_populate.cc index fab41680cb..26fd9636fc 100644 --- a/mindspore/lite/src/ops/populate/unsqueeze_populate.cc +++ b/mindspore/lite/src/ops/populate/unsqueeze_populate.cc @@ -19,36 +19,37 @@ using mindspore::schema::PrimitiveType_Unsqueeze; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateUnsqueezeParameter(const void *prim) { - auto *unsqueeze_param = reinterpret_cast(malloc(sizeof(UnSqueezeParameter))); - if (unsqueeze_param == nullptr) { - MS_LOG(ERROR) << "malloc UnSqueezeParameter failed."; - return nullptr; - } - memset(unsqueeze_param, 0, sizeof(UnSqueezeParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - unsqueeze_param->op_parameter_.type_ = primitive->value_type(); - auto unsqueeze_prim = primitive->value_as_Unsqueeze(); - if (unsqueeze_prim == nullptr) { - MS_LOG(ERROR) << "unsqueeze_prim is nullptr"; + auto value = primitive->value_as_Unsqueeze(); + if (value == nullptr) { + MS_LOG(ERROR) << "value is nullptr"; + return nullptr; + } + + auto *param = reinterpret_cast(malloc(sizeof(UnSqueezeParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc UnSqueezeParameter failed."; return nullptr; } - auto axis = unsqueeze_prim->axis(); + memset(param, 0, sizeof(UnSqueezeParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + auto axis = value->axis(); if (axis == nullptr) { MS_LOG(ERROR) << "axis is nullptr"; + free(param); return nullptr; } auto flat_axis = std::vector(axis->begin(), axis->end()); - unsqueeze_param->num_dim_ = flat_axis.size(); + param->num_dim_ = flat_axis.size(); int i = 0; - for (auto iter = flat_axis.begin(); iter != flat_axis.end(); ++iter) { - unsqueeze_param->dims_[i++] = *iter; + for (int &flat_axi : flat_axis) { + param->dims_[i++] = flat_axi; } - return reinterpret_cast(unsqueeze_param); + return reinterpret_cast(param); } -} // namespace REG_POPULATE(PrimitiveType_Unsqueeze, PopulateUnsqueezeParameter, SCHEMA_CUR) } // namespace lite diff --git a/mindspore/lite/src/ops/populate/unstack_populate.cc b/mindspore/lite/src/ops/populate/unstack_populate.cc index b47ef73b9c..3f1933e299 100644 --- a/mindspore/lite/src/ops/populate/unstack_populate.cc +++ b/mindspore/lite/src/ops/populate/unstack_populate.cc @@ -19,14 +19,7 @@ using mindspore::schema::PrimitiveType_Unstack; namespace mindspore { namespace lite { - OpParameter *PopulateUnstackParameter(const void *prim) { - auto *unstack_param = reinterpret_cast(malloc(sizeof(UnstackParameter))); - if (unstack_param == nullptr) { - MS_LOG(ERROR) << "malloc UnstackParameter failed."; - return nullptr; - } - memset(unstack_param, 0, sizeof(UnstackParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_Unstack(); @@ -34,10 +27,19 @@ OpParameter *PopulateUnstackParameter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - unstack_param->op_parameter_.type_ = primitive->value_type(); - unstack_param->axis_ = value->axis(); - return reinterpret_cast(unstack_param); + + auto *param = reinterpret_cast(malloc(sizeof(UnstackParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc UnstackParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(UnstackParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->axis_ = value->axis(); + return reinterpret_cast(param); } + REG_POPULATE(PrimitiveType_Unstack, PopulateUnstackParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/v0/broadcast_to_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/broadcast_to_populate_v0.cc index fba6931876..ae412d87c0 100644 --- a/mindspore/lite/src/ops/populate/v0/broadcast_to_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/broadcast_to_populate_v0.cc @@ -39,6 +39,7 @@ OpParameter *PopulateBroadcastToParameter(const void *prim) { broadcast_param->op_parameter_.type_ = schema::PrimitiveType_BroadcastTo; auto dst_shape = broadcast_to_prim->dst_shape(); if (dst_shape == nullptr) { + free(broadcast_param); MS_LOG(ERROR) << "dst_shape is nullptr"; return nullptr; } diff --git a/mindspore/lite/src/ops/populate/v0/common_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/common_populate_v0.cc index 1aea7aa26e..c5637eb08c 100644 --- a/mindspore/lite/src/ops/populate/v0/common_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/common_populate_v0.cc @@ -21,14 +21,16 @@ namespace mindspore { namespace lite { namespace { OpParameter *PopulateCommonParameter(const void *prim) { + auto *primitive = reinterpret_cast(prim); + MS_ASSERT(primitive != nullptr); + auto *common_parameter = reinterpret_cast(malloc(sizeof(OpParameter))); if (common_parameter == nullptr) { MS_LOG(ERROR) << "malloc OpParameter failed."; return nullptr; } memset(common_parameter, 0, sizeof(OpParameter)); - auto *primitive = reinterpret_cast(prim); - MS_ASSERT(primitive != nullptr); + auto type = primitive->value_type(); if (type == schema::v0::PrimitiveType_ZerosLike) { common_parameter->type_ = schema::PrimitiveType_ZerosLike; diff --git a/mindspore/lite/src/ops/populate/v0/constant_of_shape_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/constant_of_shape_populate_v0.cc index 20ff726222..6cfcaa73ea 100644 --- a/mindspore/lite/src/ops/populate/v0/constant_of_shape_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/constant_of_shape_populate_v0.cc @@ -40,17 +40,12 @@ OpParameter *PopulateConstantOfShapeParameter(const void *prim) { if (value->size() == 0 || value->size() > 1) { MS_LOG(ERROR) << "The value of constant of shape is empty or more than 1."; } else { - auto val = constant_of_shape_prim->value(); - if (val == nullptr) { - MS_LOG(ERROR) << "val is nullptr"; - return nullptr; - } switch (param->data_type_) { case kNumberTypeFloat32: - param->value_.f32_value_ = val->data()[0]; + param->value_.f32_value_ = value->data()[0]; break; case kNumberTypeInt32: - param->value_.int32_value_ = val->data()[0]; + param->value_.int32_value_ = value->data()[0]; break; default: MS_LOG(ERROR) << "The value of constant of shape is invalid"; diff --git a/mindspore/lite/src/ops/populate/v0/l2_norm_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/l2_norm_populate_v0.cc index f237a5e26b..ae7945bd2e 100644 --- a/mindspore/lite/src/ops/populate/v0/l2_norm_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/l2_norm_populate_v0.cc @@ -40,6 +40,7 @@ OpParameter *PopulateL2NormParameter(const void *prim) { auto axis_vec = l2_norm_prim->axis(); if (axis_vec == nullptr) { MS_LOG(ERROR) << "axis_vec is nullptr"; + free(l2_norm_parameter); return nullptr; } l2_norm_parameter->axis_num_ = axis_vec->size(); diff --git a/mindspore/lite/src/ops/populate/v0/prior_box_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/prior_box_populate_v0.cc index f74b46ea54..146c34fb08 100644 --- a/mindspore/lite/src/ops/populate/v0/prior_box_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/prior_box_populate_v0.cc @@ -40,6 +40,7 @@ OpParameter *PopulatePriorBoxParameter(const void *prim) { auto min_sizes = prior_box_prim->min_sizes(); if (min_sizes == nullptr) { MS_LOG(ERROR) << "min_sizes is nullptr"; + free(prior_box_param); return nullptr; } if (min_sizes->size() > MAX_SHAPE_SIZE) { @@ -53,6 +54,7 @@ OpParameter *PopulatePriorBoxParameter(const void *prim) { auto max_sizes = prior_box_prim->max_sizes(); if (max_sizes == nullptr) { MS_LOG(ERROR) << "max_sizes is nullptr"; + free(prior_box_param); return nullptr; } if (max_sizes->size() > MAX_SHAPE_SIZE) { @@ -66,6 +68,7 @@ OpParameter *PopulatePriorBoxParameter(const void *prim) { auto aspect_ratios = prior_box_prim->aspect_ratios(); if (aspect_ratios == nullptr) { MS_LOG(ERROR) << "aspect_ratios is nullptr"; + free(prior_box_param); return nullptr; } if (aspect_ratios->size() > MAX_SHAPE_SIZE) { @@ -79,6 +82,7 @@ OpParameter *PopulatePriorBoxParameter(const void *prim) { auto variances = prior_box_prim->variances(); if (variances == nullptr) { MS_LOG(ERROR) << "variances is nullptr"; + free(prior_box_param); return nullptr; } if (variances->size() != COMM_SHAPE_SIZE) { diff --git a/mindspore/lite/src/ops/populate/v0/reduce_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/reduce_populate_v0.cc index 033a908d19..ee64d277bb 100644 --- a/mindspore/lite/src/ops/populate/v0/reduce_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/reduce_populate_v0.cc @@ -43,6 +43,7 @@ OpParameter *PopulateReduceParameter(const void *prim) { auto axisVector = reduce_prim->axes(); if (axisVector == nullptr) { MS_LOG(ERROR) << "axisVector is nullptr"; + free(reduce_param); return nullptr; } if (axisVector->size() > MAX_SHAPE_SIZE) { @@ -52,8 +53,8 @@ OpParameter *PopulateReduceParameter(const void *prim) { } reduce_param->num_axes_ = static_cast(axisVector->size()); int i = 0; - for (auto iter = axisVector->begin(); iter != axisVector->end(); iter++) { - reduce_param->axes_[i++] = *iter; + for (int iter : *axisVector) { + reduce_param->axes_[i++] = iter; } reduce_param->mode_ = static_cast(reduce_prim->mode()); return reinterpret_cast(reduce_param); diff --git a/mindspore/lite/src/ops/populate/v0/reverse_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/reverse_populate_v0.cc index a66547d400..87c1e32c5a 100644 --- a/mindspore/lite/src/ops/populate/v0/reverse_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/reverse_populate_v0.cc @@ -39,12 +39,13 @@ OpParameter *PopulateReverseParameter(const void *prim) { auto flatAxis = reverse_prim->axis(); if (flatAxis == nullptr) { MS_LOG(ERROR) << "flatAxis is nullptr"; + free(reverse_param); return nullptr; } reverse_param->num_axis_ = flatAxis->size(); int i = 0; - for (auto iter = flatAxis->begin(); iter != flatAxis->end(); iter++) { - reverse_param->axis_[i++] = *iter; + for (int flatAxi : *flatAxis) { + reverse_param->axis_[i++] = flatAxi; } return reinterpret_cast(reverse_param); } diff --git a/mindspore/lite/src/ops/populate/v0/slice_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/slice_populate_v0.cc index d972dcd5be..c7493ba841 100644 --- a/mindspore/lite/src/ops/populate/v0/slice_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/slice_populate_v0.cc @@ -42,6 +42,7 @@ OpParameter *PopulateSliceParameter(const void *prim) { auto param_axis = slice_prim->axes(); if (param_begin == nullptr || param_size == nullptr || param_axis == nullptr) { MS_LOG(ERROR) << "nullptr"; + free(slice_param); return nullptr; } if (param_begin->size() != param_size->size() || param_begin->size() != param_axis->size()) { diff --git a/mindspore/lite/src/ops/populate/v0/tile_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/tile_populate_v0.cc index 991c479324..121231e269 100644 --- a/mindspore/lite/src/ops/populate/v0/tile_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/tile_populate_v0.cc @@ -45,10 +45,14 @@ OpParameter *PopulateTileParameter(const void *prim) { #else if (tile_prim->dims() != nullptr) { auto dims = tile_prim->dims(); - if (dims != nullptr) { - for (size_t i = 0; i < dims->size(); i++) { - tile_param->dims_[i] = static_cast(dims->Get(i)); - } + if (dims == nullptr) { + MS_LOG(ERROR) << "dims is nullptr"; + free(tile_param); + return nullptr; + } + + for (size_t i = 0; i < dims->size(); i++) { + tile_param->dims_[i] = static_cast(dims->Get(i)); } tile_param->dims_size_ = dims->size(); } diff --git a/mindspore/lite/src/ops/populate/v0/transpose_populate_v0.cc b/mindspore/lite/src/ops/populate/v0/transpose_populate_v0.cc index 8ae25c763e..c7f4d0e3cf 100644 --- a/mindspore/lite/src/ops/populate/v0/transpose_populate_v0.cc +++ b/mindspore/lite/src/ops/populate/v0/transpose_populate_v0.cc @@ -40,11 +40,12 @@ OpParameter *PopulateTransposeParameter(const void *prim) { auto perm_vector_ = transpose_prim->perm(); if (perm_vector_ == nullptr) { MS_LOG(ERROR) << "perm_vector_ is nullptr"; + free(transpose_param); return nullptr; } int i = 0; - for (auto iter = perm_vector_->begin(); iter != perm_vector_->end(); iter++) { - transpose_param->perm_[i++] = *iter; + for (int iter : *perm_vector_) { + transpose_param->perm_[i++] = iter; } transpose_param->num_axes_ = i; transpose_param->perm_size_ = perm_vector_->size(); diff --git a/mindspore/lite/src/ops/populate/where_populate.cc b/mindspore/lite/src/ops/populate/where_populate.cc index 08903b248c..01401e462f 100644 --- a/mindspore/lite/src/ops/populate/where_populate.cc +++ b/mindspore/lite/src/ops/populate/where_populate.cc @@ -19,20 +19,21 @@ using mindspore::schema::PrimitiveType_Where; namespace mindspore { namespace lite { -namespace { OpParameter *PopulateWhereParameter(const void *prim) { - auto *where_parameter = reinterpret_cast(malloc(sizeof(WhereParameter))); - if (where_parameter == nullptr) { - MS_LOG(ERROR) << "malloc Where parameter failed."; - return nullptr; - } - memset(where_parameter, 0, sizeof(OpParameter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); - where_parameter->op_parameter_.type_ = primitive->value_type(); - return reinterpret_cast(where_parameter); + + auto *param = reinterpret_cast(malloc(sizeof(WhereParameter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc WhereParameter failed."; + return nullptr; + } + memset(param, 0, sizeof(OpParameter)); + + param->op_parameter_.type_ = primitive->value_type(); + return reinterpret_cast(param); } -} // namespace + REG_POPULATE(PrimitiveType_Where, PopulateWhereParameter, SCHEMA_CUR) } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/while_populate.cc b/mindspore/lite/src/ops/populate/while_populate.cc index 632748f248..718e0214c7 100644 --- a/mindspore/lite/src/ops/populate/while_populate.cc +++ b/mindspore/lite/src/ops/populate/while_populate.cc @@ -18,7 +18,6 @@ using mindspore::schema::PrimitiveType_While; namespace mindspore { namespace lite { - typedef struct WhileParemeter { OpParameter op_parameter_; int body_subgraph_index; @@ -26,12 +25,6 @@ typedef struct WhileParemeter { } WhileParemeter; OpParameter *PopulateWhileParemeter(const void *prim) { - auto *while_paremeter = reinterpret_cast(malloc(sizeof(WhileParemeter))); - if (while_paremeter == nullptr) { - MS_LOG(ERROR) << "malloc WhileParemeter failed."; - return nullptr; - } - memset(while_paremeter, 0, sizeof(WhileParemeter)); auto primitive = static_cast(prim); MS_ASSERT(primitive != nullptr); auto value = primitive->value_as_While(); @@ -39,11 +32,20 @@ OpParameter *PopulateWhileParemeter(const void *prim) { MS_LOG(ERROR) << "value is nullptr"; return nullptr; } - while_paremeter->op_parameter_.type_ = primitive->value_type(); - while_paremeter->body_subgraph_index = value->body_subgraph_index(); - while_paremeter->cond_subgraph_index = value->cond_subgraph_index(); - return reinterpret_cast(while_paremeter); + + auto *param = reinterpret_cast(malloc(sizeof(WhileParemeter))); + if (param == nullptr) { + MS_LOG(ERROR) << "malloc WhileParemeter failed."; + return nullptr; + } + memset(param, 0, sizeof(WhileParemeter)); + + param->op_parameter_.type_ = primitive->value_type(); + param->body_subgraph_index = value->body_subgraph_index(); + param->cond_subgraph_index = value->cond_subgraph_index(); + return reinterpret_cast(param); } + REG_POPULATE(PrimitiveType_While, PopulateWhileParemeter, SCHEMA_CUR) } // namespace lite } // namespace mindspore