From d2a4fb39be298c974347c8689a7ac23d315eea10 Mon Sep 17 00:00:00 2001 From: yvette Date: Thu, 19 Nov 2020 10:49:14 +0800 Subject: [PATCH] modify static check --- mindspore/lite/src/kernel_registry.h | 9 ++-- mindspore/lite/src/model_common.cc | 12 +++-- mindspore/lite/src/param_value_lite.h | 2 +- .../src/runtime/kernel/arm/base/dequant.h | 4 +- mindspore/lite/src/runtime/thread_pool.c | 1 + .../graph/trans_format_insert_pass.cc | 44 ++++++++----------- .../graph/trans_format_insert_pass.h | 2 +- .../converter/parser/onnx/onnx_conv_parser.cc | 8 ++-- .../converter/parser/onnx/onnx_conv_parser.h | 2 +- .../parser/onnx/onnx_lp_norm_parser.cc | 19 ++++---- .../converter/parser/onnx/onnx_lrn_parser.cc | 27 +++++------- .../quantizer/post_training_quantizer.h | 14 +++--- .../fusion/constant_folding_fusion.cc | 23 +++++----- .../optimizer/fusion/conv_transform_fusion.cc | 6 +-- .../optimizer/fusion/conv_transform_fusion.h | 2 +- 15 files changed, 85 insertions(+), 90 deletions(-) diff --git a/mindspore/lite/src/kernel_registry.h b/mindspore/lite/src/kernel_registry.h index 552f6bec46..d0fc1911f5 100644 --- a/mindspore/lite/src/kernel_registry.h +++ b/mindspore/lite/src/kernel_registry.h @@ -36,13 +36,11 @@ class KernelRegistry { static KernelRegistry *GetInstance(); int Init(); - void FreeCreatorArray(); virtual kernel::KernelCreator GetCreator(const kernel::KernelKey &desc); const kernel::KernelCreator *GetCreatorArrays(); - int GetCreatorFuncIndex(const kernel::KernelKey desc); - void RegKernel(const kernel::KernelKey desc, kernel::KernelCreator creator); - void RegKernel(const kernel::KERNEL_ARCH arch, const TypeId data_type, const schema::PrimitiveType type, - kernel::KernelCreator creator); + int GetCreatorFuncIndex(kernel::KernelKey desc); + void RegKernel(kernel::KernelKey desc, kernel::KernelCreator creator); + void RegKernel(kernel::KERNEL_ARCH arch, TypeId data_type, schema::PrimitiveType type, kernel::KernelCreator creator); bool Merge(const std::unordered_map &newCreators); kernel::LiteKernel *GetKernel(const std::vector &in_tensors, const std::vector &out_tensors, const PrimitiveC *primitive, const InnerContext *ctx, const kernel::KernelKey &key); @@ -61,6 +59,7 @@ class KernelRegistrar { KernelRegistrar(const kernel::KernelKey &desc, kernel::KernelCreator creator) { KernelRegistry::GetInstance()->RegKernel(desc, creator); } + ~KernelRegistrar() = default; KernelRegistrar(const kernel::KERNEL_ARCH arch, const TypeId data_type, const schema::PrimitiveType op_type, kernel::KernelCreator creator) { diff --git a/mindspore/lite/src/model_common.cc b/mindspore/lite/src/model_common.cc index cec4738733..83780149ef 100644 --- a/mindspore/lite/src/model_common.cc +++ b/mindspore/lite/src/model_common.cc @@ -29,6 +29,7 @@ bool ConvertNodes(const schema::MetaGraph *meta_graph, Model *model) { return false; } auto c_node = meta_graph->nodes()->GetAs(i); + MS_ASSERT(c_node != nullptr); auto src_prim = c_node->primitive(); MS_ASSERT(src_prim != nullptr); #ifdef PRIMITIVE_WRITEABLE @@ -63,6 +64,8 @@ bool ConvertNodes(const schema::MetaGraph *meta_graph, Model *model) { } bool ConvertTensors(const schema::MetaGraph *meta_graph, Model *model) { + MS_ASSERT(model != nullptr); + MS_ASSERT(meta_graph != nullptr); MS_ASSERT(meta_graph->allTensors() != nullptr); auto tensor_count = meta_graph->allTensors()->size(); for (uint32_t i = 0; i < tensor_count; ++i) { @@ -165,13 +168,13 @@ Model *ImportFromBuffer(const char *model_buf, size_t size, bool take_buf) { } else { if (size == 0) { MS_LOG(ERROR) << "malloc size is equal to 0"; - delete (model); + delete model; return nullptr; } model->buf = reinterpret_cast(malloc(size)); if (model->buf == nullptr) { MS_LOG(ERROR) << "new inner model buf fail!"; - delete (model); + delete model; return nullptr; } memcpy(model->buf, model_buf, size); @@ -180,7 +183,7 @@ Model *ImportFromBuffer(const char *model_buf, size_t size, bool take_buf) { auto meta_graph = schema::GetMetaGraph(model->buf); if (meta_graph == nullptr) { MS_LOG(ERROR) << "meta_graph is nullptr!"; - delete (model); + delete model; return nullptr; } @@ -209,6 +212,7 @@ Model *ImportFromBuffer(const char *model_buf, size_t size, bool take_buf) { int ret = MetaGraphMappingSubGraph(meta_graph, model); if (ret != RET_OK) { MS_LOG(ERROR) << "converter old version model wrong."; + delete model; return nullptr; } } else { @@ -219,11 +223,13 @@ Model *ImportFromBuffer(const char *model_buf, size_t size, bool take_buf) { int ret = ConvertSubGraph(sub_graph, model); if (ret != RET_OK) { MS_LOG(ERROR) << "converter subgraph wrong."; + delete model; return nullptr; } } } if (model->sub_graphs_.empty()) { + delete model; return nullptr; } return model; diff --git a/mindspore/lite/src/param_value_lite.h b/mindspore/lite/src/param_value_lite.h index db7cf80e31..b5a8346905 100644 --- a/mindspore/lite/src/param_value_lite.h +++ b/mindspore/lite/src/param_value_lite.h @@ -27,7 +27,7 @@ namespace mindspore { class ParamValueLite : public Value { public: ParamValueLite() : tensor_addr_(nullptr), tensor_size_(0) {} - virtual ~ParamValueLite() { + ~ParamValueLite() override { if (tensor_addr_ != nullptr) { auto tensor_mem = reinterpret_cast(tensor_addr_); delete[](tensor_mem); diff --git a/mindspore/lite/src/runtime/kernel/arm/base/dequant.h b/mindspore/lite/src/runtime/kernel/arm/base/dequant.h index 1363fb0515..3193f380dd 100644 --- a/mindspore/lite/src/runtime/kernel/arm/base/dequant.h +++ b/mindspore/lite/src/runtime/kernel/arm/base/dequant.h @@ -58,7 +58,7 @@ class DequantUtil { } } } else if (input_tensor->GetQuantParams().size() != kPerTensor) { - size_t channels = static_cast(input_tensor->Batch()); + auto channels = static_cast(input_tensor->Batch()); if (input_tensor->GetQuantParams().size() != channels) { MS_LOG(ERROR) << "Quant param not equal channel num " << input_tensor->GetQuantParams().size() << channels; free(dequant_datas); @@ -136,6 +136,8 @@ class DequantUtil { template static void UnPackUtil(const schema::Tensor *input_tensor, int origin_bit, void *unpack_int_data) { + MS_ASSERT(input_tensor != nullptr); + MS_ASSERT(input_tensor->data() != nullptr); auto weight_data = input_tensor->data()->data(); int pack_size = input_tensor->dataType() == kNumberTypeInt8 ? input_tensor->data()->size() : input_tensor->data()->size() / 2; diff --git a/mindspore/lite/src/runtime/thread_pool.c b/mindspore/lite/src/runtime/thread_pool.c index 9e7ed80c0e..90c326d2ac 100644 --- a/mindspore/lite/src/runtime/thread_pool.c +++ b/mindspore/lite/src/runtime/thread_pool.c @@ -848,6 +848,7 @@ ThreadPool *CreateThreadPool(int thread_num, int mode) { if (thread_pool->thread_list == NULL) { LOG_ERROR("create thread list failed"); DestroyThreadPool(thread_pool); + thread_pool = NULL; return NULL; } thread_pool->thread_list->head = NULL; diff --git a/mindspore/lite/tools/converter/legacy_optimizer/graph/trans_format_insert_pass.cc b/mindspore/lite/tools/converter/legacy_optimizer/graph/trans_format_insert_pass.cc index 690a20a298..5aa81c25f5 100644 --- a/mindspore/lite/tools/converter/legacy_optimizer/graph/trans_format_insert_pass.cc +++ b/mindspore/lite/tools/converter/legacy_optimizer/graph/trans_format_insert_pass.cc @@ -14,17 +14,14 @@ * limitations under the License. */ -#include #include #include -#include #include "tools/converter/legacy_optimizer/graph/trans_format_insert_pass.h" #include "tools/common/node_util.h" #include "src/common/log_adapter.h" #include "src/common/utils.h" -namespace mindspore { -namespace lite { +namespace mindspore::lite { bool TransOpInsertPass::CanFusion(schema::MetaGraphT *graph, const std::unique_ptr &node) { auto input_node_indexes = GetInputNodeIdx(*graph, *node); pre_type_ = schema::PrimitiveType_NONE; @@ -90,7 +87,6 @@ bool TransOpInsertPass::CanFusion(schema::MetaGraphT *graph, const std::unique_p if (GetCNodeTType(*node) == schema::PrimitiveType_Activation) { MS_ASSERT(node != nullptr); MS_ASSERT(node->primitive != nullptr); - MS_ASSERT(node->primitive->value != nullptr); MS_ASSERT(node->primitive->value.AsActivation() != nullptr); if (node->primitive->value.AsActivation() != nullptr && node->primitive->value.AsActivation()->type == schema::ActivationType_LEAKY_RELU) { @@ -131,7 +127,6 @@ STATUS TransOpInsertPass::ChangeOpAxis(schema::MetaGraphT *graph, const std::uni MS_LOG(ERROR) << "node or primitive null"; return RET_NULL_PTR; } - MS_ASSERT(node->primitive->value != nullptr); auto type = node->primitive->value.type; auto input1_ndim = graph->allTensors.at(node->inputIndex[0])->dims.size(); if (input1_ndim != 4) { @@ -147,14 +142,14 @@ STATUS TransOpInsertPass::ChangeOpAxis(schema::MetaGraphT *graph, const std::uni } } if (type == PrimitiveType_Concat) { - MS_ASSERT(node->primitive->value.AsConcat() != nullptr); - auto origin_axis = node->primitive->value.AsConcat()->axis; - auto axis_map = GetNc2NhAxisMap(); - if (node->primitive->value.AsConcat() == nullptr) { + auto attr = node->primitive->value.AsConcat(); + if (attr == nullptr) { MS_LOG(ERROR) << "node->primitive->value.AsConcat() is nullptr"; return RET_NULL_PTR; } - node->primitive->value.AsConcat()->axis = axis_map[origin_axis]; + auto origin_axis = attr->axis; + auto axis_map = GetNc2NhAxisMap(); + attr->axis = axis_map[origin_axis]; } if (type == PrimitiveType_StridedSlice) { auto attr = node->primitive->value.AsStridedSlice(); @@ -170,25 +165,25 @@ STATUS TransOpInsertPass::ChangeOpAxis(schema::MetaGraphT *graph, const std::uni attr->stride = {origin_stride[NCHW_N], origin_stride[NCHW_H], origin_stride[NCHW_W], origin_stride[NCHW_C]}; } if (type == PrimitiveType_Split) { - MS_ASSERT(node->primitive->value.AsSplit() != nullptr); - auto origin_axis = node->primitive->value.AsSplit()->splitDim; - auto axis_map = GetNc2NhAxisMap(); - if (node->primitive->value.AsSplit() == nullptr) { + auto attr = node->primitive->value.AsSplit(); + if (attr == nullptr) { MS_LOG(ERROR) << "node->primitive->value.AsSplit() is nullptr"; return RET_NULL_PTR; } - node->primitive->value.AsSplit()->splitDim = axis_map[origin_axis]; + auto origin_axis = attr->splitDim; + auto axis_map = GetNc2NhAxisMap(); + attr->splitDim = axis_map[origin_axis]; } if (type == PrimitiveType_Crop) { - MS_ASSERT(node->primitive->value.AsCrop() != nullptr); - auto origin_axis = node->primitive->value.AsCrop()->axis; - auto offsets = node->primitive->value.AsCrop()->offsets; - auto axis_map = GetNc2NhAxisMap(); - if (node->primitive->value.AsCrop() == nullptr) { + auto attr = node->primitive->value.AsCrop(); + if (attr == nullptr) { MS_LOG(ERROR) << "node->primitive->value.AsCrop() is nullptr"; return RET_NULL_PTR; } - node->primitive->value.AsCrop()->axis = axis_map[origin_axis]; + auto origin_axis = attr->axis; + auto offsets = attr->offsets; + auto axis_map = GetNc2NhAxisMap(); + attr->axis = axis_map[origin_axis]; // nchw->nhwc,offsets need pad 0; if (axis_map[origin_axis] == 0) { offsets = {offsets[0], offsets[2], offsets[3], offsets[1]}; @@ -203,7 +198,7 @@ STATUS TransOpInsertPass::ChangeOpAxis(schema::MetaGraphT *graph, const std::uni MS_LOG(ERROR) << "Crop error"; return RET_ERROR; } - node->primitive->value.AsCrop()->offsets = offsets; + attr->offsets = offsets; } if (type == PrimitiveType_Slice) { auto attr = node->primitive->value.AsSlice(); @@ -278,5 +273,4 @@ STATUS TransOpInsertPass::Run(schema::MetaGraphT *graph) { } return RET_OK; } -} // namespace lite -} // namespace mindspore +} // namespace mindspore::lite diff --git a/mindspore/lite/tools/converter/legacy_optimizer/graph/trans_format_insert_pass.h b/mindspore/lite/tools/converter/legacy_optimizer/graph/trans_format_insert_pass.h index 5304632162..772f537faa 100644 --- a/mindspore/lite/tools/converter/legacy_optimizer/graph/trans_format_insert_pass.h +++ b/mindspore/lite/tools/converter/legacy_optimizer/graph/trans_format_insert_pass.h @@ -37,7 +37,7 @@ class TransOpInsertPass : public FormatTransPass { STATUS FindOutTransType(); - STATUS ChangeOpAxis(schema::MetaGraphT *graph, const std::unique_ptr &node); + static STATUS ChangeOpAxis(schema::MetaGraphT *graph, const std::unique_ptr &node); private: FormatTransNodeType pre_insert_trans_type_ = kNHWC2NCHW; diff --git a/mindspore/lite/tools/converter/parser/onnx/onnx_conv_parser.cc b/mindspore/lite/tools/converter/parser/onnx/onnx_conv_parser.cc index e21aeef91b..d297a15475 100644 --- a/mindspore/lite/tools/converter/parser/onnx/onnx_conv_parser.cc +++ b/mindspore/lite/tools/converter/parser/onnx/onnx_conv_parser.cc @@ -19,8 +19,7 @@ #include #include -namespace mindspore { -namespace lite { +namespace mindspore::lite { constexpr int32_t kSingleGroup = 1; bool OnnxConvParser::ParseGroupConvolution(const std::unique_ptr &attr, schema::CNodeT *op) { MS_LOG(DEBUG) << "onnx DepthwiseConvParser"; @@ -139,6 +138,7 @@ STATUS OnnxConvParser::Parse(const onnx::GraphProto &onnx_graph, const onnx::Nod } std::vector weight_shape; auto size = (*nodeIter).dims_size(); + weight_shape.reserve(size); for (int i = 0; i < size; ++i) { weight_shape.emplace_back((*nodeIter).dims(i)); } @@ -156,7 +156,6 @@ STATUS OnnxConvParser::Parse(const onnx::GraphProto &onnx_graph, const onnx::Nod auto iter = std::find_if((*nodeIter).attribute().begin(), (*nodeIter).attribute().end(), [](const onnx::AttributeProto &attr) { return attr.name() == "shape"; }); if (iter != (*nodeIter).attribute().end()) { - MS_ASSERT(iter->ints() != nullptr); MS_ASSERT(iter->ints().begin() != nullptr); MS_ASSERT(iter->ints().end() != nullptr); dims.insert(dims.begin(), iter->ints().begin(), iter->ints().end()); @@ -188,5 +187,4 @@ OnnxNodeRegistrar g_onnxConvParser("Conv", new OnnxConvParser()); OnnxNodeRegistrar g_onnxInt8ConvParser("Int8Conv", new OnnxConvParser()); OnnxNodeRegistrar g_onnxConvReluParser("ConvRelu", new OnnxConvParser()); OnnxNodeRegistrar g_onnxInt8ConvReluParser("Int8ConvRelu", new OnnxConvParser()); -} // namespace lite -} // namespace mindspore +} // namespace mindspore::lite diff --git a/mindspore/lite/tools/converter/parser/onnx/onnx_conv_parser.h b/mindspore/lite/tools/converter/parser/onnx/onnx_conv_parser.h index ab2e8cf5d0..0162c6ffe4 100644 --- a/mindspore/lite/tools/converter/parser/onnx/onnx_conv_parser.h +++ b/mindspore/lite/tools/converter/parser/onnx/onnx_conv_parser.h @@ -31,7 +31,7 @@ class OnnxConvParser : public OnnxNodeParser { STATUS Parse(const onnx::GraphProto &onnx_graph, const onnx::NodeProto &onnx_node, schema::CNodeT *op) override; private: - bool ParseGroupConvolution(const std::unique_ptr &attr, schema::CNodeT *op); + static bool ParseGroupConvolution(const std::unique_ptr &attr, schema::CNodeT *op); }; } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/tools/converter/parser/onnx/onnx_lp_norm_parser.cc b/mindspore/lite/tools/converter/parser/onnx/onnx_lp_norm_parser.cc index 6835de0201..bddbfe9bdf 100644 --- a/mindspore/lite/tools/converter/parser/onnx/onnx_lp_norm_parser.cc +++ b/mindspore/lite/tools/converter/parser/onnx/onnx_lp_norm_parser.cc @@ -17,8 +17,7 @@ #include "tools/converter/parser/onnx/onnx_lp_norm_parser.h" #include -namespace mindspore { -namespace lite { +namespace mindspore::lite { STATUS OnnxLpNormParser::Parse(const onnx::GraphProto &onnx_graph, const onnx::NodeProto &onnx_node, schema::CNodeT *op) { MS_LOG(DEBUG) << "onnx LpNormParser"; @@ -38,13 +37,12 @@ STATUS OnnxLpNormParser::Parse(const onnx::GraphProto &onnx_graph, const onnx::N return RET_NULL_PTR; } - auto onnx_node_attr = onnx_node.attribute(); - for (int i = 0; i < onnx_node_attr.size(); ++i) { - MS_ASSERT(onnx_node_attr.at(i) != nullptr); - if (onnx_node_attr.at(i).name() == "axis") { - attr->axis = onnx_node_attr.at(i).i(); - } else if (onnx_node_attr.at(i).name() == "p") { - attr->p = onnx_node_attr.at(i).i(); + for (const auto &onnx_node_attr : onnx_node.attribute()) { + const auto &attribute_name = onnx_node_attr.name(); + if (attribute_name == "axis") { + attr->axis = onnx_node_attr.i(); + } else if (attribute_name == "p") { + attr->p = onnx_node_attr.i(); } } @@ -54,5 +52,4 @@ STATUS OnnxLpNormParser::Parse(const onnx::GraphProto &onnx_graph, const onnx::N } OnnxNodeRegistrar g_onnxLpNormParser("LpNormalization", new OnnxLpNormParser()); -} // namespace lite -} // namespace mindspore +} // namespace mindspore::lite diff --git a/mindspore/lite/tools/converter/parser/onnx/onnx_lrn_parser.cc b/mindspore/lite/tools/converter/parser/onnx/onnx_lrn_parser.cc index f27ae16415..267abfa8b8 100644 --- a/mindspore/lite/tools/converter/parser/onnx/onnx_lrn_parser.cc +++ b/mindspore/lite/tools/converter/parser/onnx/onnx_lrn_parser.cc @@ -17,8 +17,7 @@ #include "tools/converter/parser/onnx/onnx_lrn_parser.h" #include -namespace mindspore { -namespace lite { +namespace mindspore::lite { STATUS OnnxLrnParser::Parse(const onnx::GraphProto &onnx_graph, const onnx::NodeProto &onnx_node, schema::CNodeT *op) { MS_LOG(DEBUG) << "onnx LrnParser"; if (op == nullptr) { @@ -37,18 +36,17 @@ STATUS OnnxLrnParser::Parse(const onnx::GraphProto &onnx_graph, const onnx::Node return RET_NULL_PTR; } - auto onnx_node_attr = onnx_node.attribute(); int32_t size = 0; - for (int i = 0; i < onnx_node_attr.size(); ++i) { - MS_ASSERT(onnx_node_attr.at(i) != nullptr); - if (onnx_node_attr.at(i).name() == "alpha") { - attr->alpha = onnx_node_attr.at(i).f(); - } else if (onnx_node_attr.at(i).name() == "beta") { - attr->beta = onnx_node_attr.at(i).f(); - } else if (onnx_node_attr.at(i).name() == "bias") { - attr->bias = onnx_node_attr.at(i).f(); - } else if (onnx_node_attr.at(i).name() == "size") { - size = static_cast(onnx_node_attr.at(i).i()); + for (const auto &onnx_node_attr : onnx_node.attribute()) { + const auto &attribute_name = onnx_node_attr.name(); + if (attribute_name == "alpha") { + attr->alpha = onnx_node_attr.f(); + } else if (attribute_name == "beta") { + attr->beta = onnx_node_attr.f(); + } else if (attribute_name == "bias") { + attr->bias = onnx_node_attr.f(); + } else if (attribute_name == "size") { + size = static_cast(onnx_node_attr.i()); attr->depth_radius = size / 2; } } @@ -66,5 +64,4 @@ STATUS OnnxLrnParser::Parse(const onnx::GraphProto &onnx_graph, const onnx::Node OnnxNodeRegistrar g_onnxLrnxParser("Lrn", new OnnxLrnParser()); OnnxNodeRegistrar g_onnxLRNxParser("LRN", new OnnxLrnParser()); -} // namespace lite -} // namespace mindspore +} // namespace mindspore::lite diff --git a/mindspore/lite/tools/converter/quantizer/post_training_quantizer.h b/mindspore/lite/tools/converter/quantizer/post_training_quantizer.h index a96ecf49fc..baac54b342 100644 --- a/mindspore/lite/tools/converter/quantizer/post_training_quantizer.h +++ b/mindspore/lite/tools/converter/quantizer/post_training_quantizer.h @@ -192,22 +192,24 @@ class Calibrator { STATUS AddQuantizedOp(const CNodePtr &node); - STATUS RecordMaxValue(const std::vector &data, const std::unique_ptr &diverg_info); + static STATUS RecordMaxValue(const std::vector &data, const std::unique_ptr &diverg_info); - STATUS UpdateDivergInverval(std::unordered_map>> *diverg_info); + static STATUS UpdateDivergInverval( + std::unordered_map>> *diverg_info); - STATUS UpdateDataFrequency(const std::vector &data, const std::unique_ptr &diverg_info); + static STATUS UpdateDataFrequency(const std::vector &data, const std::unique_ptr &diverg_info); void Dump(); STATUS ComputeThreshold(); - std::unordered_map GetScale( + static std::unordered_map GetScale( std::unordered_map> *diverg_info); - std::unordered_map GetZeropoint( + static std::unordered_map GetZeropoint( std::unordered_map> *diverg_info); - std::map GetMinMax(std::unordered_map> *diverg_info); + static std::map GetMinMax( + std::unordered_map> *diverg_info); std::unordered_map>> *GetInputDivergInfo(); diff --git a/mindspore/lite/tools/optimizer/fusion/constant_folding_fusion.cc b/mindspore/lite/tools/optimizer/fusion/constant_folding_fusion.cc index dcca234c65..b1224cfb9a 100644 --- a/mindspore/lite/tools/optimizer/fusion/constant_folding_fusion.cc +++ b/mindspore/lite/tools/optimizer/fusion/constant_folding_fusion.cc @@ -106,8 +106,9 @@ ParameterPtr CreateNewParamter(const FuncGraphPtr &func_graph, Tensor *tensor) { parameter->set_default_param(param_value); return parameter; } -kernel::LiteKernel *GetLiteKernel(std::vector inputs, std::vector outputs, OpParameter *parameter, - lite::InnerContext *context, mindspore::lite::PrimitiveC *primitive) { +kernel::LiteKernel *GetLiteKernel(std::vector inputs, const std::vector &outputs, + OpParameter *parameter, lite::InnerContext *context, + mindspore::lite::PrimitiveC *primitive) { MS_ASSERT(nullptr != lite_primitive); auto data_type = inputs.front()->data_type(); kernel::KernelKey desc{kernel::KERNEL_ARCH::kCPU, data_type, (schema::PrimitiveType)primitive->Type()}; @@ -159,15 +160,15 @@ lite::STATUS ReplaceCNode(const FuncGraphPtr &func_graph, const CNodePtr &any_no } // namespace void FreeTensors(std::vector *input_tensor, std::vector *output_tensor) { if (input_tensor != nullptr) { - for (size_t i = 0; i < input_tensor->size(); i++) { - delete (*input_tensor)[i]; - (*input_tensor)[i] = nullptr; + for (auto &i : *input_tensor) { + delete i; + i = nullptr; } } if (output_tensor != nullptr) { - for (size_t i = 0; i < output_tensor->size(); i++) { - delete (*output_tensor)[i]; - (*output_tensor)[i] = nullptr; + for (auto &i : *output_tensor) { + delete i; + i = nullptr; } } } @@ -227,9 +228,9 @@ const AnfNodePtr ConstFoldPass::Process(const FuncGraphPtr &func_graph, const An // here, input_tensor's format need to be transposed nhwc according to fmkType, // but for the time being, we only transpose the tensor with 0/1/2/3D. // Others should be added in future. - for (size_t j = 0; j < input_tensors.size(); ++j) { - input_tensors[j]->SetFormat(schema::Format::Format_NHWC); - if (input_tensors[j]->shape().size() == 4) { + for (auto &input_tensor : input_tensors) { + input_tensor->SetFormat(schema::Format::Format_NHWC); + if (input_tensor->shape().size() == 4) { MS_LOG(INFO) << "init input_tensor format to nhwc"; } } diff --git a/mindspore/lite/tools/optimizer/fusion/conv_transform_fusion.cc b/mindspore/lite/tools/optimizer/fusion/conv_transform_fusion.cc index a841e4d55d..55d6c7b2ae 100644 --- a/mindspore/lite/tools/optimizer/fusion/conv_transform_fusion.cc +++ b/mindspore/lite/tools/optimizer/fusion/conv_transform_fusion.cc @@ -234,13 +234,11 @@ const void ConvTransformFusion::CalNewWeightTensor(float *weight_data, int kerne return; } - if (tmp_weight_data != nullptr) { - delete[] tmp_weight_data; - } + delete[] tmp_weight_data; } const void ConvTransformFusion::CalNewBiasTensor(float *bias_data, int kernel_num, bool bias_flag, - const float *trans_scale, const float *trans_bias) const { + const float *trans_scale, const float *trans_bias) { MS_ASSERT(bias_data != nullptr); if (bias_flag) { auto tmp_bias_data = new (std::nothrow) float[kernel_num]; diff --git a/mindspore/lite/tools/optimizer/fusion/conv_transform_fusion.h b/mindspore/lite/tools/optimizer/fusion/conv_transform_fusion.h index 2017b0de27..da161c0192 100644 --- a/mindspore/lite/tools/optimizer/fusion/conv_transform_fusion.h +++ b/mindspore/lite/tools/optimizer/fusion/conv_transform_fusion.h @@ -31,7 +31,7 @@ class ConvTransformFusion : public PatternProcessPass { virtual const void InitTransParam(const CNodePtr &, int, float *, float *) const = 0; const void GenNewConvTensor(const FuncGraphPtr &, const CNodePtr &, int, const float *, const float *) const; const void CalNewWeightTensor(float *, int, int, const float *) const; - const void CalNewBiasTensor(float *, int, bool, const float *, const float *) const; + static const void CalNewBiasTensor(float *, int, bool, const float *, const float *); }; } // namespace mindspore::opt #endif // MINDSPORE_LITE_SRC_PASS_FUSION_CONV_TRANSFORM_FUSION_H_