From 1224fa13f37ac6e43516e60e0ceb117e4f874177 Mon Sep 17 00:00:00 2001 From: zhaozhenlong Date: Tue, 24 Nov 2020 15:29:42 +0800 Subject: [PATCH] fix code review fp32 int8 --- mindspore/lite/nnacl/int8/squeeze_int8.c | 11 +- mindspore/lite/nnacl/int8/squeeze_int8.h | 4 +- mindspore/lite/nnacl/quantization/quantize.h | 14 +- .../kernel/arm/fp32/lsh_projection_fp32.cc | 2 + .../src/runtime/kernel/arm/fp32/lstm_fp32.cc | 9 +- .../runtime/kernel/arm/fp32/matmul_fp32.cc | 4 + .../src/runtime/kernel/arm/fp32/pad_fp32.cc | 9 +- .../src/runtime/kernel/arm/fp32/power_fp32.cc | 3 + .../src/runtime/kernel/arm/fp32/prelu_fp32.cc | 3 +- .../src/runtime/kernel/arm/fp32/range_fp32.cc | 1 + .../src/runtime/kernel/arm/fp32/rank_fp32.cc | 1 + .../runtime/kernel/arm/fp32/reduce_fp32.cc | 6 +- .../runtime/kernel/arm/fp32/reshape_fp32.cc | 2 + .../kernel/arm/fp32/reverse_sequence_fp32.cc | 6 +- .../kernel/arm/fp32/roi_pooling_fp32.cc | 5 + .../kernel/arm/fp32/scatter_nd_fp32.cc | 1 + .../runtime/kernel/arm/fp32/skip_gram_fp32.cc | 1 + .../src/runtime/kernel/arm/fp32/slice_fp32.cc | 2 + .../runtime/kernel/arm/fp32/softmax_fp32.cc | 4 + .../kernel/arm/fp32/space_to_batch_fp32.cc | 4 +- .../kernel/arm/fp32/space_to_depth_fp32.cc | 4 +- .../kernel/arm/fp32/sparse_to_dense_fp32.cc | 17 +- .../src/runtime/kernel/arm/fp32/split_fp32.cc | 1 + .../runtime/kernel/arm/fp32/squeeze_fp32.cc | 2 + .../src/runtime/kernel/arm/fp32/stack_fp32.cc | 9 +- .../src/runtime/kernel/arm/fp32/tile_fp32.cc | 4 +- .../src/runtime/kernel/arm/fp32/topk_fp32.cc | 6 + .../runtime/kernel/arm/fp32/transpose_fp32.cc | 7 +- .../runtime/kernel/arm/fp32/unique_fp32.cc | 3 + .../runtime/kernel/arm/fp32/unsqueeze_fp32.cc | 2 + .../runtime/kernel/arm/fp32/unstack_fp32.cc | 2 + .../src/runtime/kernel/arm/fp32/where_fp32.cc | 8 + .../runtime/kernel/arm/int8/l2_norm_int8.cc | 3 + .../kernel/arm/int8/leaky_relu_int8.cc | 45 ++--- .../src/runtime/kernel/arm/int8/mul_int8.cc | 3 + .../src/runtime/kernel/arm/int8/pad_int8.cc | 9 + .../runtime/kernel/arm/int8/pooling_int8.cc | 3 + .../src/runtime/kernel/arm/int8/power_int8.cc | 4 + .../src/runtime/kernel/arm/int8/relux_int8.cc | 2 + .../src/runtime/kernel/arm/int8/relux_int8.h | 6 +- .../runtime/kernel/arm/int8/reshape_int8.cc | 4 +- .../src/runtime/kernel/arm/int8/scale_int8.cc | 10 +- .../runtime/kernel/arm/int8/sigmoid_int8.cc | 2 + .../src/runtime/kernel/arm/int8/slice_int8.cc | 5 +- .../src/runtime/kernel/arm/int8/slice_int8.h | 2 +- .../runtime/kernel/arm/int8/softmax_int8.cc | 2 + .../runtime/kernel/arm/int8/softmax_int8.h | 2 +- .../kernel/arm/int8/space_to_batch_int8.cc | 5 + .../kernel/arm/int8/space_to_batch_int8.h | 2 +- .../src/runtime/kernel/arm/int8/split_int8.cc | 2 + .../runtime/kernel/arm/int8/squeeze_int8.cc | 168 +++++------------- .../runtime/kernel/arm/int8/squeeze_int8.h | 4 +- .../src/runtime/kernel/arm/int8/sub_int8.h | 2 +- .../src/runtime/kernel/arm/int8/topk_int8.cc | 9 +- .../src/runtime/kernel/arm/int8/topk_int8.h | 8 +- .../runtime/kernel/arm/int8/transpose_int8.cc | 9 +- .../runtime/kernel/arm/int8/transpose_int8.h | 2 +- .../runtime/kernel/arm/int8/unsqueeze_int8.cc | 14 +- .../runtime/kernel/arm/int8/unsqueeze_int8.h | 6 +- 59 files changed, 274 insertions(+), 216 deletions(-) diff --git a/mindspore/lite/nnacl/int8/squeeze_int8.c b/mindspore/lite/nnacl/int8/squeeze_int8.c index bbf7b91728..5f6870fc69 100644 --- a/mindspore/lite/nnacl/int8/squeeze_int8.c +++ b/mindspore/lite/nnacl/int8/squeeze_int8.c @@ -17,16 +17,15 @@ #include "nnacl/int8/squeeze_int8.h" #include -void Squeeze(int8_t **inputs, int8_t *output_ptr, int task_id, SqueezeQuantArg *quant_Squeeze_parm, - SqueezeParameter *para_, size_t osize) { - float output_scale = quant_Squeeze_parm->out_quant_args_.scale_; +void SqueezeInt8(const int8_t *input_ptr, int8_t *output_ptr, int task_id, SqueezeQuantArg *quant_Squeeze_parm, + SqueezeParameter *para_, const int num) { + float output_scale = quant_Squeeze_parm->out_quant_args_->scale_; const float output_inverse_scale = 1.f / output_scale; QuantArg *input_quant = quant_Squeeze_parm->in_quant_args_; - int output_zp = quant_Squeeze_parm->out_quant_args_.zp_; + int output_zp = quant_Squeeze_parm->out_quant_args_->zp_; const int i = 0; - int8_t *input_ptr = inputs[0]; - for (int j = task_id; j < osize; j += para_->op_parameter_.thread_num_) { + for (int j = task_id; j < num; j += para_->op_parameter_.thread_num_) { float scale = input_quant[i].scale_ * output_inverse_scale; float bias = -input_quant[i].zp_ * scale; int32_t output_tmp = round(input_ptr[j] * scale + bias) + output_zp; diff --git a/mindspore/lite/nnacl/int8/squeeze_int8.h b/mindspore/lite/nnacl/int8/squeeze_int8.h index b769d2b0bc..6119c4c653 100644 --- a/mindspore/lite/nnacl/int8/squeeze_int8.h +++ b/mindspore/lite/nnacl/int8/squeeze_int8.h @@ -23,8 +23,8 @@ #ifdef __cplusplus extern "C" { #endif -void Squeeze(int8_t **inputs, int8_t *output_ptr, int task_id, SqueezeQuantArg *quant_Squeeze_parm, - SqueezeParameter *para_, size_t osize); +void SqueezeInt8(const int8_t *input_ptr, int8_t *output_ptr, int task_id, SqueezeQuantArg *quant_Squeeze_parm, + SqueezeParameter *para_, const int num); #ifdef __cplusplus } #endif diff --git a/mindspore/lite/nnacl/quantization/quantize.h b/mindspore/lite/nnacl/quantization/quantize.h index b43bbc1931..0d04d9aa13 100644 --- a/mindspore/lite/nnacl/quantization/quantize.h +++ b/mindspore/lite/nnacl/quantization/quantize.h @@ -58,16 +58,8 @@ typedef struct ConcatQuantArg { } ConcatQuantArg; typedef struct SqueezeQuantArg { - int *input_sizes_; - int output_size_; - int **input_shapes_; - int *output_shape_; - float alpha; - int axis_; - size_t input_num_; - size_t output_dim_; QuantArg *in_quant_args_; - QuantArg out_quant_args_; + QuantArg *out_quant_args_; } SqueezeQuantArg; typedef struct UnSqueezeQuantArg { @@ -254,8 +246,8 @@ typedef struct LeakyReluQuantArg { PreluQuantArg quant_arg; float slope_; int64_t axis_; - const int *in_shape_; - const int *out_shape_; + int *in_shape_; + int *out_shape_; int input_dim_; int element_num; } LeakyReluQuantArg; diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/lsh_projection_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/lsh_projection_fp32.cc index 72ac199ccc..d2f267d505 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/lsh_projection_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/lsh_projection_fp32.cc @@ -90,8 +90,10 @@ void LshProjectionCPUKernel::FreeKeys() { if (param_->hash_buffs_ != nullptr) { for (int i = 0; i < op_parameter_->thread_num_; i++) { context_->allocator->Free(param_->hash_buffs_[i]); + param_->hash_buffs_[i] = nullptr; } context_->allocator->Free(param_->hash_buffs_); + param_->hash_buffs_ = nullptr; } } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/lstm_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/lstm_fp32.cc index 3abbc71279..1f8b6401dd 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/lstm_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/lstm_fp32.cc @@ -135,12 +135,14 @@ int LstmCPUKernel::ReSize() { ret = InitWeightBias(); if (ret != RET_OK) { MS_LOG(ERROR) << "LstmCPUKernel InitWeightBias error."; + FreeTmpBuffer(); return RET_ERROR; } ret = InitBuffer(); if (ret != RET_OK) { MS_LOG(ERROR) << "LstmCPUKernel InitBuffer error."; + FreeTmpBuffer(); return RET_ERROR; } return RET_OK; @@ -157,13 +159,18 @@ int LstmCPUKernel::Run() { MS_ASSERT(output != nullptr); auto input_ptr = reinterpret_cast(input->MutableData()); + MS_ASSERT(input_ptr); auto output_ptr = reinterpret_cast(output->MutableData()); - + MS_ASSERT(output_ptr); auto output_hidden_state = out_tensors_[1]; memcpy(output_hidden_state->MutableData(), hidden_state->MutableData(), hidden_state->ElementsNum() * sizeof(float)); auto output_cell_state = out_tensors_[2]; memcpy(output_cell_state->MutableData(), cell_state->MutableData(), cell_state->ElementsNum() * sizeof(float)); + MS_ASSERT(weight_h_ptr_); + MS_ASSERT(weight_i_ptr_); + MS_ASSERT(bias_ptr_); + MS_ASSERT(gate_buffer_); Lstm(output_ptr, input_ptr, weight_i_ptr_, weight_h_ptr_, bias_ptr_, reinterpret_cast(output_hidden_state->MutableData()), reinterpret_cast(output_cell_state->MutableData()), gate_buffer_, lstm_parm_); diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/matmul_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/matmul_fp32.cc index cf250a950e..7e59bf5f07 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/matmul_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/matmul_fp32.cc @@ -258,6 +258,10 @@ int MatmulCPUKernel::RunImpl(int task_id) { auto b = cur_b_ptr_ + task_id * thread_stride_ * C8NUM * params_->deep_; auto c = cur_c_ptr_ + task_id * thread_stride_ * C8NUM; auto bias = bias_ptr_ ? bias_ptr_ + task_id * thread_stride_ * C8NUM : NULL; + MS_ASSERT(cur_a_ptr_); + MS_ASSERT(b); + MS_ASSERT(c); + MS_ASSERT(bias); if (is_vector_a_) { MatVecMul(cur_a_ptr_, b, c, bias, ActType_No, params_->deep_, cur_oc); } else { diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/pad_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/pad_fp32.cc index 751b3831f2..4c0ee529c2 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/pad_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/pad_fp32.cc @@ -16,6 +16,7 @@ #include "src/runtime/kernel/arm/fp32/pad_fp32.h" #include +#include #include "src/kernel_registry.h" #include "schema/model_generated.h" #include "include/errorcode.h" @@ -111,10 +112,12 @@ int PadImpl(void *cdata, int task_id) { int PadCPUKernel::RunImpl(int task_id) { auto input = in_tensors_.at(0); auto output = out_tensors_.at(0); - + MS_ASSERT(input); + MS_ASSERT(output); auto input_data = reinterpret_cast(input->MutableData()); auto output_data = reinterpret_cast(output->MutableData()); - + MS_ASSERT(input_data); + MS_ASSERT(output_data); Pad(input_data, output_data, in_, out_, pad_param_->paddings_, task_id, context_->thread_num_); return RET_OK; @@ -241,7 +244,7 @@ int PadCPUKernel::Run() { auto output = out_tensors_.at(0); int output_size = output->ElementsNum(); auto output_data = reinterpret_cast(output->MutableData()); - if (pad_param_->constant_value_ - 0.0f < 1e-5) { + if (abs(pad_param_->constant_value_ - 0.0f) < 1e-5) { memset(output_data, 0, output_size * sizeof(float)); } else { for (auto i = 0; i < output_size; ++i) { diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/power_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/power_fp32.cc index a991c1ee68..3920b0e9dc 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/power_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/power_fp32.cc @@ -51,7 +51,9 @@ int PowerCPUKernel::Run() { int PowerCPUKernel::RunImpl(int task_id) { auto x_addr = reinterpret_cast(in_tensors_[0]->MutableData()); + MS_ASSERT(x_addr); auto output_addr = reinterpret_cast(out_tensors_[0]->MutableData()); + MS_ASSERT(output_addr); auto size = in_tensors_[0]->ElementsNum(); int stride = UP_DIV(size, thread_count_); int len = MSMIN(stride, size - stride * task_id); @@ -59,6 +61,7 @@ int PowerCPUKernel::RunImpl(int task_id) { bool broadcast = true; if (in_tensors_.size() == 2) { exp_addr = reinterpret_cast(in_tensors_[1]->MutableData()); + MS_ASSERT(exp_addr); broadcast = in_tensors_[0]->shape() == in_tensors_[1]->shape() ? false : true; } float *cur_exp = nullptr; diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/prelu_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/prelu_fp32.cc index 1bb9745902..7f487cf2f9 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/prelu_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/prelu_fp32.cc @@ -111,7 +111,8 @@ int PReluCPUKernel::Run() { auto input_tensor = in_tensors_[0]; ori_input_ = reinterpret_cast(input_tensor->MutableData()); output_data_ = reinterpret_cast(out_tensors_.at(kOutputIndex)->MutableData()); - + MS_ASSERT(ori_input_); + MS_ASSERT(output_data_); if (prelu_param_->channelShared) { auto ret = ProcessShareChannelInput(); if (ret != RET_OK) { diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/range_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/range_fp32.cc index 4a08dd654c..9ca46cbedb 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/range_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/range_fp32.cc @@ -48,6 +48,7 @@ int RangeCPUKernel::Run() { } } auto output_ptr = reinterpret_cast(out_tensors_.at(0)->data_c()); + MS_ASSERT(output_ptr); Range(output_ptr, start, limit, delta); return RET_OK; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/rank_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/rank_fp32.cc index 88c2a9aa09..2c0b87d48b 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/rank_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/rank_fp32.cc @@ -33,6 +33,7 @@ int RankCPUKernel::ReSize() { return RET_OK; } int RankCPUKernel::Run() { auto output_ptr = reinterpret_cast(out_tensors_.at(0)->MutableData()); + MS_ASSERT(output_ptr); auto in_shape = in_tensors_[0]->shape(); auto rank = in_shape.size(); Rank(output_ptr, rank); diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/reduce_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/reduce_fp32.cc index 09075ca63b..0c5d055cb9 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/reduce_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/reduce_fp32.cc @@ -15,6 +15,7 @@ */ #include "src/runtime/kernel/arm/fp32/reduce_fp32.h" +#include #include "schema/model_generated.h" #include "src/kernel_registry.h" #include "include/errorcode.h" @@ -144,9 +145,10 @@ int ReduceCPUKernel::Run() { } src_data_ = dst_data_; } - if (reduce_param_->reduce_to_end_ && reduce_param_->coeff - 1.0f > 1e-5) { + if (reduce_param_->reduce_to_end_ && abs(reduce_param_->coeff - 1.0f) > 1e-5) { ret = CalculateCoeffOutput(); if (ret != RET_OK) { + FreeTmpBuffer(); return ret; } } @@ -213,7 +215,7 @@ int ReduceCPUKernel::MallocTmpBuffer() { } void ReduceCPUKernel::FreeTmpBuffer() { - for (auto buffer : data_buffers_) { + for (auto &buffer : data_buffers_) { if (buffer != nullptr) { context_->allocator->Free(buffer); buffer = nullptr; diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/reshape_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/reshape_fp32.cc index 56584f05df..6703180ec1 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/reshape_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/reshape_fp32.cc @@ -39,6 +39,8 @@ int ReshapeCPUKernel::Run() { auto input_ptr = in_tensors_.at(kInputIndex)->MutableData(); auto output_ptr = out_tensors_.at(kOutputIndex)->MutableData(); size_t data_size = in_tensors_.at(kInputIndex)->Size(); + MS_ASSERT(input_ptr); + MS_ASSERT(output_ptr); Reshape(input_ptr, output_ptr, data_size); return RET_OK; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/reverse_sequence_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/reverse_sequence_fp32.cc index ccb3a1622b..cc2e68400a 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/reverse_sequence_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/reverse_sequence_fp32.cc @@ -32,7 +32,7 @@ int ReverseSequenceCPUKernel::Init() { void ReverseSequenceCPUKernel::ConvertAxisToPositive(const std::vector shape, int *axis) { if (axis != nullptr && *axis < 0) { - *axis += shape.size(); + *axis += static_cast(shape.size()); } } @@ -91,7 +91,11 @@ int ReverseSequenceCPUKernel::Run() { void *input1 = in_tensors_.at(1)->MutableData(); float *output = reinterpret_cast(out_tensors_.at(0)->MutableData()); ReverseSequenceParameter *param = reinterpret_cast(op_parameter_); + MS_ASSERT(param); param->is_seq_length_int32_ = in_tensors_.at(1)->data_type() == kNumberTypeInt32; + MS_ASSERT(input0); + MS_ASSERT(input1); + MS_ASSERT(output); ReverseSequence(input0, input1, output, param); return RET_OK; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/roi_pooling_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/roi_pooling_fp32.cc index b474adcfb8..e009e1c1ba 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/roi_pooling_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/roi_pooling_fp32.cc @@ -74,6 +74,11 @@ int ROIPoolingCPUKernel::ReSize() { } int ROIPoolingCPUKernel::DoExecute(int task_id) { + MS_ASSERT(in_ptr_); + MS_ASSERT(out_ptr_); + MS_ASSERT(roi_ptr_); + MS_ASSERT(max_c_); + MS_ASSERT(param_); auto ret = ROIPooling(in_ptr_, out_ptr_, roi_ptr_, max_c_, task_id, param_); if (ret != RET_OK) { MS_LOG(ERROR) << "ROIPooling Execute error task_id[" << task_id << "] error_code[" << ret << "]"; diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/scatter_nd_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/scatter_nd_fp32.cc index 1010c53a62..5d9c12b859 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/scatter_nd_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/scatter_nd_fp32.cc @@ -108,6 +108,7 @@ int ScatterNDCPUKernel::ReSize() { } int *indices_ptr = reinterpret_cast(indices->MutableData()); + output_unit_offsets_.clear(); for (int i = 0; i < num_unit_; i++) { int tmp_stride = 0; for (int j = 0; j < indice_unit_rank; j++) { diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/skip_gram_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/skip_gram_fp32.cc index c6b3bd5169..722b56de24 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/skip_gram_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/skip_gram_fp32.cc @@ -61,6 +61,7 @@ void ParseSentenceToWords(const StringPack &sentence, std::vector *w int SkipGramCPUKernel::Run() { skip_gram_parameter_ = reinterpret_cast(op_parameter_); + MS_ASSERT(skip_gram_parameter_); if (skip_gram_parameter_->ngram_size < 1) { MS_LOG(ERROR) << "Skip Gram Parameter Error, NgramSize should be at least 1, get " << skip_gram_parameter_->ngram_size; diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/slice_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/slice_fp32.cc index cb87f0f85c..dd916fa0f0 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/slice_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/slice_fp32.cc @@ -65,6 +65,8 @@ int SliceCPUKernel::Init() { int SliceCPUKernel::SliceParallelRun(int thread_id) { const float *input_data = reinterpret_cast(in_tensors_[0]->MutableData()); float *output_data = reinterpret_cast(out_tensors_[0]->MutableData()); + MS_ASSERT(input_data); + MS_ASSERT(output_data); DoSlice(input_data, output_data, param_, thread_id); return RET_OK; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/softmax_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/softmax_fp32.cc index c2643ae75c..2cc58f5155 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/softmax_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/softmax_fp32.cc @@ -93,7 +93,9 @@ int SoftmaxLastAxisRun(void *cdata, int task_id) { int SoftmaxCPUKernel::Run() { auto input_ptr = reinterpret_cast(in_tensors_.at(kInputIndex)->MutableData()); + MS_ASSERT(input_ptr); auto output_ptr = reinterpret_cast(out_tensors_.at(kOutputIndex)->MutableData()); + MS_ASSERT(output_ptr); int ret = RET_OK; if (in_plane_size_ == 1) { ret = ParallelLaunch(this->context_->thread_pool_, SoftmaxLastAxisRun, this, context_->thread_num_); @@ -101,7 +103,9 @@ int SoftmaxCPUKernel::Run() { MS_LOG(ERROR) << "SoftmaxCPUKernel ParallelLaunch failed, ret: " << ret; } } else { + MS_ASSERT(sum_data_); memset(sum_data_, 0, in_plane_size_ * out_plane_size_ * sizeof(float)); + MS_ASSERT(softmax_param_); Softmax(input_ptr, output_ptr, sum_data_, softmax_param_); } return ret; diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/space_to_batch_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/space_to_batch_fp32.cc index 362684c0fd..3ad85db272 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/space_to_batch_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/space_to_batch_fp32.cc @@ -40,8 +40,10 @@ int SpaceToBatchFp32Run(void *cdata, int task_id) { int SpaceToBatchCPUKernel::ReSize() { auto input_tensor = in_tensors_.at(0); + MS_ASSERT(input_tensor); auto output_tensor = out_tensors_.at(0); - + MS_ASSERT(output_tensor); + MS_ASSERT(param); for (size_t i = 0; i < DIMENSION_4D; i++) { param_->input_shape_[i] = input_tensor->shape().at(i); param_->output_shape_[i] = output_tensor->shape().at(i); diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/space_to_depth_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/space_to_depth_fp32.cc index 3d05ea3ca0..a5abe1074f 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/space_to_depth_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/space_to_depth_fp32.cc @@ -65,6 +65,9 @@ int SpaceToDepthCPUKernel::SpaceToDepth(int task_id) { auto in_shape = in_tensors_[0]->shape(); auto out_shape = out_tensors_[0]->shape(); SpaceToDepthParameter *param = reinterpret_cast(op_parameter_); + MS_ASSERT(param); + MS_ASSERT(input_ptr_); + MS_ASSERT(output_ptr_); auto ret = SpaceToDepthForNHWC(input_ptr_, output_ptr_, in_shape.data(), out_shape.data(), in_shape.size(), param->block_size_, thread_offset, thread_offset + num_unit_thread); if (ret != RET_OK) { @@ -93,7 +96,6 @@ int SpaceToDepthCPUKernel::Run() { MS_LOG(ERROR) << "SpaceToDepth error error_code[" << ret << "]"; return ret; } - return RET_OK; } else { MS_LOG(ERROR) << "Only support NHWC now!"; return RET_ERROR; diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/sparse_to_dense_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/sparse_to_dense_fp32.cc index 20a914e3e6..d9e907d646 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/sparse_to_dense_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/sparse_to_dense_fp32.cc @@ -33,7 +33,9 @@ using mindspore::schema::PrimitiveType_SparseToDense; namespace mindspore::kernel { int SparseToDenseCPUKernel::Init() { auto input2 = in_tensors_.at(2); + MS_ASSERT(input2); auto input3 = in_tensors_.at(3); + MS_ASSERT(input3); sparse_values = reinterpret_cast(input2->MutableData()); default_value = reinterpret_cast(input3->MutableData())[0]; if (input2->ElementsNum() == 1) { @@ -68,6 +70,10 @@ int SparseToDenseCPUKernel::DoExcute(int task_id) { int index_start = task_id * count_unit_; int index_end = index_start + real_dst_count; int out_width = output_num / index_num; + MS_ASSERT(sparse_indices_vect); + MS_ASSERT(output_shape); + MS_ASSERT(sparse_values); + MS_ASSERT(output_data); SparseToDense(sparse_indices_vect, output_shape, sparse_values, default_value, output_data, isScalar, index_start, index_end, out_width); return RET_OK; @@ -172,15 +178,16 @@ int SparseToDenseCPUKernel::Run() { return RET_ERROR; } - for (int i = 0; i < index_num; i++) { - if (sparse_indices_vect[i] != nullptr) { - delete sparse_indices_vect[i]; - } - } if (sparse_indices_vect != nullptr) { + for (int i = 0; i < index_num; i++) { + if (sparse_indices_vect[i] != nullptr) { + delete sparse_indices_vect[i]; + } + } ctx_->allocator->Free(sparse_indices_vect); sparse_indices_vect = nullptr; } + return RET_OK; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/split_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/split_fp32.cc index d1f5e7913f..7c8ccd0521 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/split_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/split_fp32.cc @@ -53,6 +53,7 @@ int SplitCPUKernel::Split(int task_id) { return RET_OK; } int thread_offset = task_id * thread_n_stride_; + MS_ASSERT(input_ptr_); auto ret = DoSplit(input_ptr_, output_ptr_.data(), in_tensors_.front()->shape().data(), thread_offset, num_unit_thread, param); if (ret != RET_OK) { diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/squeeze_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/squeeze_fp32.cc index 7a9831378f..25321322ab 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/squeeze_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/squeeze_fp32.cc @@ -34,6 +34,8 @@ int SqueezeCPUKernel::ReSize() { return RET_OK; } int SqueezeCPUKernel::Run() { mindspore::lite::STATUS ret = RET_ERROR; size_t data_size = in_tensors_.front()->Size(); + MS_ASSERT(input_ptr); + MS_ASSERT(output_ptr); if (in_tensors_.front()->data_type() == kNumberTypeInt32) { auto input_ptr = reinterpret_cast(in_tensors_.front()->MutableData()); auto output_ptr = reinterpret_cast(out_tensors_.front()->MutableData()); diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/stack_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/stack_fp32.cc index 756a00f3c4..3ce64362de 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/stack_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/stack_fp32.cc @@ -47,22 +47,29 @@ int StackCPUKernel::Run() { auto input0 = in_tensors_[0]; if (inputs_num == 1) { auto *output_data = reinterpret_cast(out_tensors_[0]->MutableData()); - DoStackOneInput(reinterpret_cast(input0->MutableData()), output_data, input0->Size()); + MS_ASSERT(output_data); + auto *input_data = reinterpret_cast(input0->MutableData()); + MS_ASSERT(input_data); + DoStackOneInput(input_data, output_data, input0->Size()); return RET_OK; } auto input0_shape = in_tensors_[0]->shape(); if (in_tensors_[0]->data_type() == kNumberTypeFloat32 || in_tensors_[0]->data_type() == kNumberTypeFloat) { auto *output_data = reinterpret_cast(out_tensors_[0]->MutableData()); + MS_ASSERT(output_data); float *inputs[inputs_num]; for (size_t i = 0; i < inputs_num; ++i) { inputs[i] = reinterpret_cast(in_tensors_[i]->MutableData()); + MS_ASSERT(inputs[i]); } DoStack(inputs, inputs_num, input0_shape.data(), input0_shape.size(), axis_, output_data); } else { auto *output_data = reinterpret_cast(out_tensors_[0]->MutableData()); + MS_ASSERT(output_data); int32_t *inputs[inputs_num]; for (size_t i = 0; i < inputs_num; ++i) { inputs[i] = reinterpret_cast(in_tensors_[i]->MutableData()); + MS_ASSERT(inputs[i]); } DoStackInt32(inputs, inputs_num, input0_shape.data(), input0_shape.size(), axis_, output_data); } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/tile_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/tile_fp32.cc index 3b212ea887..1833246772 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/tile_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/tile_fp32.cc @@ -41,6 +41,7 @@ void TileCPUKernel::ComputeStrides(const int *shape, int *strides, int ndim) { int TileCPUKernel::ReSize() { auto tile_parameter_ = reinterpret_cast(op_parameter_); + MS_ASSERT(tile_parameter_); tile_parameter_->in_dim_ = in_tensors_[0]->shape().size(); for (int i = 0; i < tile_parameter_->in_dim_; ++i) { tile_parameter_->in_shape_[i] = in_tensors_[0]->shape()[i]; @@ -54,7 +55,8 @@ int TileCPUKernel::ReSize() { int TileCPUKernel::Run() { auto input_addr = reinterpret_cast(in_tensors_.at(0)->MutableData()); auto output_addr = reinterpret_cast(out_tensors_.at(0)->MutableData()); - + MS_ASSERT(input_addr); + MS_ASSERT(output_addr); Tile(input_addr, output_addr, reinterpret_cast(op_parameter_)); return RET_OK; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/topk_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/topk_fp32.cc index 708d3acd48..e159898d98 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/topk_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/topk_fp32.cc @@ -26,6 +26,7 @@ using mindspore::schema::PrimitiveType_TopK; namespace mindspore::kernel { int TopKCPUKernel::Init() { TopkParameter *parameter = reinterpret_cast(op_parameter_); + MS_ASSERT(parameter); parameter->topk_node_list_ = nullptr; if (!InferShapeDone()) { return RET_OK; @@ -46,11 +47,15 @@ int TopKCPUKernel::ReSize() { int TopKCPUKernel::Run() { auto input_data = reinterpret_cast(in_tensors_.at(0)->MutableData()); + MS_ASSERT(input_data); auto output_data = reinterpret_cast(out_tensors_.at(0)->MutableData()); + MS_ASSERT(output_data); auto output_index = reinterpret_cast(out_tensors_.at(1)->MutableData()); + MS_ASSERT(output_index); MS_ASSERT(context_->allocator != nullptr); TopkParameter *parameter = reinterpret_cast(op_parameter_); + MS_ASSERT(parameter); if (in_tensors_.size() == lite::kDoubleNum) { auto input_k = reinterpret_cast(in_tensors_.at(1)->MutableData()); parameter->k_ = input_k[0]; @@ -66,6 +71,7 @@ int TopKCPUKernel::Run() { } Topk(input_data, output_data, output_index, reinterpret_cast(op_parameter_)); context_->allocator->Free(parameter->topk_node_list_); + parameter->topk_node_list_ = nullptr; return RET_OK; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/transpose_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/transpose_fp32.cc index 08cf7df921..7f34602cd5 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/transpose_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/transpose_fp32.cc @@ -53,6 +53,7 @@ int TransposeCPUKernel::ReSize() { } if (this->in_shape_ != nullptr) { free(this->in_shape_); + in_shape_ = nullptr; } if (this->out_shape_ != nullptr) { free(this->out_shape_); @@ -89,13 +90,17 @@ int TransposeCPUKernel::TransposeParallel(int task_id) { } int thread_offset = task_id * thread_h_stride_; TransposeParameter *param = reinterpret_cast(this->op_parameter_); - + MS_ASSERT(param); int *size = nullptr; int *position = nullptr; if (this->dim_size_ != nullptr && this->position_ != nullptr) { size = this->dim_size_ + task_id * param->num_axes_; position = this->position_ + task_id * param->num_axes_; } + MS_ASSERT(in_data_); + MS_ASSERT(out_data_); + MS_ASSERT(in_shape_); + MS_ASSERT(out_shape_); auto ret = DoTransposeFp32(in_data_, out_data_, in_shape_, out_shape_, param, thread_offset, thread_offset + num_unit_thread, size, position); if (ret != RET_OK) { diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/unique_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/unique_fp32.cc index 132052958e..0dd44f84ec 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/unique_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/unique_fp32.cc @@ -29,8 +29,11 @@ int UniqueCPUKernel::ReSize() { return RET_OK; } int UniqueCPUKernel::Run() { auto input = reinterpret_cast(in_tensors_.at(0)->MutableData()); + MS_ASSERT(input); auto output0 = reinterpret_cast(out_tensors_.at(0)->MutableData()); + MS_ASSERT(output0); auto output1 = reinterpret_cast(out_tensors_.at(1)->MutableData()); + MS_ASSERT(output1); int output0_len = 0; Unique(input, in_tensors_.at(0)->ElementsNum(), output0, &output0_len, output1); diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/unsqueeze_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/unsqueeze_fp32.cc index 7a9110f467..9189edc9d8 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/unsqueeze_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/unsqueeze_fp32.cc @@ -47,6 +47,8 @@ int UnsqueezeCPUKernel::DoUnsqueeze(int task_id) { return RET_OK; } size_t offset = task_id * thread_sz_stride_ * sizeof(float); + MS_ASSERT(in_ptr_); + MS_ASSERT(out_ptr_); int ret = Unsqueeze(in_ptr_ + offset, out_ptr_ + offset, size * sizeof(float)); if (ret != RET_OK) { MS_LOG(ERROR) << "UnsqueezeRun error task_id[" << task_id << "] error_code[" << ret << "]"; diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/unstack_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/unstack_fp32.cc index ebd7733bfe..87535715c3 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/unstack_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/unstack_fp32.cc @@ -65,10 +65,12 @@ int UnstackCPUKernel::ReSize() { int UnstackCPUKernel::Run() { float *input = reinterpret_cast(in_tensors_.at(0)->MutableData()); + MS_ASSERT(input); size_t out_num = out_tensors_.size(); for (size_t i = 0; i < out_num; i++) { output_addr_array_[i] = reinterpret_cast(out_tensors_.at(i)->MutableData()); } + MS_ASSERT(output_addr_array_); Unistack(input, output_addr_array_, reinterpret_cast(op_parameter_)); return RET_OK; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/where_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/where_fp32.cc index e551f3ec30..895f77857e 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/where_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/where_fp32.cc @@ -34,6 +34,11 @@ int WhereCPUKernel::Init() { } int WhereCPUKernel::DoExcute(int task_id) { + MS_ASSERT(input_data); + MS_ASSERT(input_data1); + MS_ASSERT(input_data2); + MS_ASSERT(output_data); + MS_ASSERT(where_param_); Where(input_data, input_data1, input_data2, output_data, where_param_, task_id); return RET_OK; } @@ -49,8 +54,11 @@ int WhereRun(void *cdata, int task_id) { } int WhereCPUKernel::Run() { auto input = in_tensors_.at(0); + MS_ASSERT(input); auto input1 = in_tensors_.at(1); + MS_ASSERT(input1); auto input2 = in_tensors_.at(2); + MS_ASSERT(input2); int num = input->ElementsNum(); int num1_ = input1->ElementsNum(); int num2_ = input2->ElementsNum(); diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/l2_norm_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/l2_norm_int8.cc index de5aafc4ee..f3d50384a6 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/l2_norm_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/l2_norm_int8.cc @@ -63,7 +63,10 @@ int L2NormInt8CPUKernel::DoExecute(int task_id) { int end = MSMIN(begin + stride, outer_size); int8_t *input_data = static_cast(in_tensors().front()->MutableData()); + MS_ASSERT(input_data); int8_t *output_data = static_cast(out_tensors().front()->MutableData()); + MS_ASSERT(output_data); + MS_ASSERT(l2_norm_param_); return L2NormalizationInt8(input_data, output_data, l2_norm_param_, &quant_param_, begin, end); } diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/leaky_relu_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/leaky_relu_int8.cc index 0d35fc1376..84690fa4db 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/leaky_relu_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/leaky_relu_int8.cc @@ -63,16 +63,6 @@ int LeakyReluInt8CPUKernel::Init() { quant_prelu_parm_.quant_arg.output_activation_max_ = std::numeric_limits::max(); quant_prelu_parm_.quant_arg.output_activation_min_ = std::numeric_limits::min(); - quant_prelu_parm_.in_shape_ = reinterpret_cast(malloc(input_tensor->shape().size() * sizeof(int))); - if (quant_prelu_parm_.in_shape_ == nullptr) { - MS_LOG(ERROR) << "malloc memory failed"; - return RET_MEMORY_FAILED; - } - quant_prelu_parm_.out_shape_ = reinterpret_cast(malloc(out_tensor->shape().size() * sizeof(int))); - if (quant_prelu_parm_.out_shape_ == nullptr) { - MS_LOG(ERROR) << "malloc memory failed"; - return RET_MEMORY_FAILED; - } if (!InferShapeDone()) { return RET_OK; } @@ -81,11 +71,11 @@ int LeakyReluInt8CPUKernel::Init() { LeakyReluInt8CPUKernel::~LeakyReluInt8CPUKernel() { if (quant_prelu_parm_.in_shape_ != nullptr) { - free(const_cast(quant_prelu_parm_.in_shape_)); + free(quant_prelu_parm_.in_shape_); quant_prelu_parm_.in_shape_ = nullptr; } if (quant_prelu_parm_.out_shape_ != nullptr) { - free(const_cast(quant_prelu_parm_.out_shape_)); + free(quant_prelu_parm_.out_shape_); quant_prelu_parm_.out_shape_ = nullptr; } } @@ -97,22 +87,31 @@ int LeakyReluInt8CPUKernel::ReSize() { quant_prelu_parm_.input_dim_ = input_dim; quant_prelu_parm_.element_num = in_tensors_[0]->Size(); auto input_shape = input_tensor->shape(); + if (quant_prelu_parm_.in_shape_ != nullptr) { + free(quant_prelu_parm_.in_shape_); + quant_prelu_parm_.in_shape_ = nullptr; + } + quant_prelu_parm_.in_shape_ = reinterpret_cast(malloc(input_shape.size() * sizeof(int))); if (quant_prelu_parm_.in_shape_ == nullptr) { - MS_LOG(ERROR) << "in_shape_ is nullptr"; - return RET_ERROR; - } else { - memcpy(reinterpret_cast(const_cast(quant_prelu_parm_.in_shape_)), input_shape.data(), - sizeof(int) * input_dim); + MS_LOG(ERROR) << "malloc memory failed"; + return RET_MEMORY_FAILED; } + memcpy(reinterpret_cast(const_cast(quant_prelu_parm_.in_shape_)), input_shape.data(), + sizeof(int) * input_dim); + auto output_shape = out_tensor->shape(); size_t output_dim = output_shape.size(); + if (quant_prelu_parm_.out_shape_ != nullptr) { + free(quant_prelu_parm_.out_shape_); + quant_prelu_parm_.out_shape_ = nullptr; + } + quant_prelu_parm_.out_shape_ = reinterpret_cast(malloc(output_dim * sizeof(int))); if (quant_prelu_parm_.out_shape_ == nullptr) { - MS_LOG(ERROR) << "out_shape_ is nullptr"; - return RET_ERROR; - } else { - memcpy(reinterpret_cast(const_cast(quant_prelu_parm_.out_shape_)), output_shape.data(), - sizeof(int) * output_dim); + MS_LOG(ERROR) << "malloc memory failed"; + return RET_MEMORY_FAILED; } + memcpy(reinterpret_cast(const_cast(quant_prelu_parm_.out_shape_)), output_shape.data(), + sizeof(int) * output_dim); return RET_OK; } @@ -129,6 +128,8 @@ int LeakyReluInt8CPUKernel::DoExecute(int task_id) { auto out_tensor = out_tensors_.at(kOutputIndex); int8_t *input_data = reinterpret_cast(input_tensor->MutableData()); int8_t *output_data = reinterpret_cast(out_tensor->MutableData()); + MS_ASSERT(input_data); + MS_ASSERT(output_data); auto ret = DoLeakReluInt8(input_data, output_data, &quant_prelu_parm_, task_id); if (ret != NNACL_OK) { MS_LOG(ERROR) << "DoLeakReluInt8 failed"; diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/mul_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/mul_int8.cc index f7b24b4170..93ae94c5bb 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/mul_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/mul_int8.cc @@ -138,8 +138,11 @@ int MulInt8CPUKernel::ReSize() { int MulInt8CPUKernel::Run() { input0_data_ = static_cast(in_tensors_.at(0)->MutableData()); + MS_ASSERT(input0_data_); input1_data_ = static_cast(in_tensors_.at(1)->MutableData()); + MS_ASSERT(input1_data_); output_data_ = static_cast(out_tensors_.at(0)->MutableData()); + MS_ASSERT(output_data_); CheckIfFastImpl(); // can implement fast broadcast mul diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/pad_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/pad_int8.cc index 3f8ac91f4a..d901eb70e9 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/pad_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/pad_int8.cc @@ -115,6 +115,7 @@ int PadInt8CPUKernel::ReSize() { } int PadInt8CPUKernel::Init() { + MS_ASSERT(pad_param_); auto error_code = SetQuantParam(); if (error_code != RET_OK) { MS_LOG(ERROR) << "SetQuantParam failed. errorcode: " << error_code; @@ -127,6 +128,10 @@ int PadInt8CPUKernel::Init() { } int PadInt8CPUKernel::RunImpl(int task_id) { + MS_ASSERT(in_data_); + MS_ASSERT(out_data_); + MS_ASSERT(in_dims_); + MS_ASSERT(out_dims_); return PadConstant4D(in_data_, out_data_, in_dims_, out_dims_, pad_param_->paddings_, task_id, context_->thread_num_); } @@ -183,9 +188,13 @@ int PadInt8CPUKernel::ExtendPaddings(int *paddings, int length, const int *ori_p int PadInt8CPUKernel::RunMirrorPadImpl(int task_id) { auto input = in_tensors_.at(0); + MS_ASSERT(input); auto output = out_tensors_.at(0); + MS_ASSERT(output); auto input_data = reinterpret_cast(input->MutableData()); + MS_ASSERT(input_data); auto output_data = reinterpret_cast(output->MutableData()); + MS_ASSERT(output_data); int unit = UP_DIV(output->ElementsNum(), context_->thread_num_); int begin = unit * task_id; diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/pooling_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/pooling_int8.cc index e814eeb101..a6542e4bf8 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/pooling_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/pooling_int8.cc @@ -65,7 +65,10 @@ int PoolingInt8CPUKernel::ReSize() { int PoolingInt8CPUKernel::RunImpl(int task_id) { auto input_data = reinterpret_cast(in_tensors_.at(kInputIndex)->MutableData()); + MS_ASSERT(input_data); auto output_data = reinterpret_cast(out_tensors_.at(kOutputIndex)->MutableData()); + MS_ASSERT(output_data); + MS_ASSERT(pooling_param_); if (pooling_param_->pool_mode_ == PoolMode_MaxPool) { if (pooling_param_->quantize_) { MaxPoolingWithQuantInt8(input_data, output_data, pooling_param_, task_id); diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/power_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/power_int8.cc index 946bbec6cb..57abe0b883 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/power_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/power_int8.cc @@ -62,12 +62,15 @@ int PowerInt8CPUKernel::ReSize() { return PowerBaseCPUKernel::ReSize(); } int PowerInt8CPUKernel::DoPower(int task_id) { const int8_t *input_data = reinterpret_cast(in_tensors_[0]->MutableData()); + MS_ASSERT(input_data); int8_t *output_data = reinterpret_cast(out_tensors_[0]->MutableData()); + MS_ASSERT(output_data); auto size = in_tensors_[0]->ElementsNum(); int stride = UP_DIV(size, op_parameter_->thread_num_); int count = MSMIN(stride, size - stride * task_id); int8_t *exp_ptr = nullptr; + MS_ASSERT(param_); param_->broadcast_ = true; if (in_tensors_.size() == 2) { auto exp_tensor = in_tensors_.at(1); @@ -75,6 +78,7 @@ int PowerInt8CPUKernel::DoPower(int task_id) { param_->quant_arg_.exp_args_.scale_ = exp_quant_args.front().scale; param_->quant_arg_.exp_args_.zp_ = exp_quant_args.front().zeroPoint; exp_ptr = reinterpret_cast(exp_tensor->MutableData()); + MS_ASSERT(exp_ptr); param_->broadcast_ = false; if (in_tensors_[0]->Size() != in_tensors_[1]->Size()) { MS_LOG(ERROR) << "Power input size " << in_tensors_[0]->Size() << " is not equal to exponent size " diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/relux_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/relux_int8.cc index 45fb4b50de..848c57e8a2 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/relux_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/relux_int8.cc @@ -48,7 +48,9 @@ int ReluXInt8CPUKernel::ReSize() { return RET_OK; } int ReluXInt8CPUKernel::DoActivation(int task_id) { auto input_addr = reinterpret_cast(in_tensors_.at(0)->MutableData()); + MS_ASSERT(input_addr); auto output_addr = reinterpret_cast(out_tensors_.at(0)->MutableData()); + MS_ASSERT(output_addr); auto length = in_tensors_.at(0)->ElementsNum(); int stride = UP_DIV(length, op_parameter_->thread_num_); diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/relux_int8.h b/mindspore/lite/src/runtime/kernel/arm/int8/relux_int8.h index 5b266af2e4..69a191a1d6 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/relux_int8.h +++ b/mindspore/lite/src/runtime/kernel/arm/int8/relux_int8.h @@ -14,8 +14,8 @@ * limitations under the License. */ -#ifndef MINDSPORE_LITE_SRC_BACKEND_ARM_INT8_ACTIVATION_H_ -#define MINDSPORE_LITE_SRC_BACKEND_ARM_INT8_ACTIVATION_H_ +#ifndef MINDSPORE_LITE_SRC_BACKEND_ARM_INT8_RELUX_INT8_H_ +#define MINDSPORE_LITE_SRC_BACKEND_ARM_INT8_RELUX_INT8_H_ #include #include "src/lite_kernel.h" @@ -79,4 +79,4 @@ class Relu6Int8CPUKernel : public ReluXInt8CPUKernel { }; } // namespace mindspore::kernel -#endif // MINDSPORE_LITE_SRC_BACKEND_ARM_INT8_ACTIVATION_H_ +#endif // MINDSPORE_LITE_SRC_BACKEND_ARM_INT8_RELUX_INT8_H_ diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/reshape_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/reshape_int8.cc index 3c8520f474..511f4a834d 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/reshape_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/reshape_int8.cc @@ -48,7 +48,7 @@ int ReshapeInt8CPUKernel::Init() { return RET_OK; } -int ReshapeInt8CPUKernel::ReSize() { return 0; } +int ReshapeInt8CPUKernel::ReSize() { return RET_OK; } int ReshapeInt8CPUKernel::Run() { MS_ASSERT(in_tensors_.size() == 1 || in_tensors_.size() == 2); @@ -74,6 +74,8 @@ int ReshapeInt8CPUKernel::DoExecute(int task_id) { if (real_dst_count <= 0) { return lite::RET_OK; } + MS_ASSERT(input_data_); + MS_ASSERT(output_data_); int8_t *cur_input0_data = input_data_ + task_id * count_unit_; int8_t *cur_output_data = output_data_ + task_id * count_unit_; diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/scale_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/scale_int8.cc index 1662c81099..7635df4b4b 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/scale_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/scale_int8.cc @@ -86,8 +86,10 @@ int ScaleInt8CPUKernel::InitScaleOffset() { input2_data_ = reinterpret_cast(malloc(out_tensors_.at(0)->Size())); if (input2_data_ == nullptr) { MS_LOG(ERROR) << "malloc input2_data_ failed."; - free(input1_data_); - input1_data_ = nullptr; + if (malloced_scale_) { + free(input1_data_); + input1_data_ = nullptr; + } return RET_ERROR; } malloced_offset_ = true; @@ -261,11 +263,15 @@ int ScaleInt8CPUKernel::Scale(int task_id) { return lite::RET_OK; } int8_t *cur_input0_data = input0_data_ + task_id * count_unit_; + MS_ASSERT(cur_input0_data); int8_t *cur_input1_data = input1_data_ + task_id * count_unit_; + MS_ASSERT(cur_input1_data); int8_t *cur_output_data = output_data_ + task_id * count_unit_; + MS_ASSERT(cur_output_data); if (has_bias_) { int8_t *cur_input2_data = input2_data_ + task_id * count_unit_; + MS_ASSERT(cur_input2_data); DoScaleWithBiasInt8(cur_input0_data, cur_output_data, cur_input1_data, cur_input2_data, scale_param_, real_dst_count); } else { diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/sigmoid_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/sigmoid_int8.cc index 8381ec4627..091c263b27 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/sigmoid_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/sigmoid_int8.cc @@ -67,7 +67,9 @@ int SigmoidInt8CPUKernel::ReSize() { return RET_OK; } int SigmoidInt8CPUKernel::DoActivation(int task_id) { auto input_addr = reinterpret_cast(in_tensors_.at(0)->MutableData()); + MS_ASSERT(input_addr); auto output_addr = reinterpret_cast(out_tensors_.at(0)->MutableData()); + MS_ASSERT(output_addr); auto length = in_tensors_.at(0)->ElementsNum(); int stride = UP_DIV(length, op_parameter_->thread_num_); int count = MSMIN(stride, length - stride * task_id); diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/slice_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/slice_int8.cc index 914538f4d3..aefe9821bd 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/slice_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/slice_int8.cc @@ -52,7 +52,9 @@ int SliceInt8CPUKernel::Init() { int SliceInt8CPUKernel::DoSlice(int task_id) { const int8_t *input_data = reinterpret_cast(in_tensors_[0]->MutableData()); + MS_ASSERT(input_data); int8_t *output_data = reinterpret_cast(out_tensors_[0]->MutableData()); + MS_ASSERT(output_data); auto ret = SliceInt8(input_data, output_data, param_, task_id); if (ret != RET_OK) { @@ -72,8 +74,9 @@ int SliceInt8Run(void *cdata, int task_id) { int SliceInt8CPUKernel::Run() { const int8_t *input_data = reinterpret_cast(in_tensors_[0]->MutableData()); + MS_ASSERT(input_data); int8_t *output_data = reinterpret_cast(out_tensors_[0]->MutableData()); - + MS_ASSERT(output_data); mindspore::lite::STATUS ret = RET_ERROR; if (param_->size_[1] < param_->op_parameter_.thread_num_) { ret = SliceInt8NoParallel(input_data, output_data, param_); diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/slice_int8.h b/mindspore/lite/src/runtime/kernel/arm/int8/slice_int8.h index 992c29a609..79ec68fdac 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/slice_int8.h +++ b/mindspore/lite/src/runtime/kernel/arm/int8/slice_int8.h @@ -28,7 +28,7 @@ class SliceInt8CPUKernel : public SliceCPUKernel { const std::vector &outputs, const lite::InnerContext *ctx, const mindspore::lite::PrimitiveC *primitive) : SliceCPUKernel(parameter, inputs, outputs, ctx, primitive) {} - ~SliceInt8CPUKernel() {} + ~SliceInt8CPUKernel() = default; int Init() override; int Run() override; diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/softmax_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/softmax_int8.cc index f331371ba6..732b9f67b2 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/softmax_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/softmax_int8.cc @@ -74,7 +74,9 @@ int SoftmaxInt8CPUKernel::DoSoftmax(int task_id) { MS_ASSERT(out_tensors_.size() == 1); auto input_ptr = reinterpret_cast(in_tensors_.at(0)->MutableData()); + MS_ASSERT(input_ptr); auto output_ptr = reinterpret_cast(out_tensors_.at(0)->MutableData()); + MS_ASSERT(output_ptr); int outter_size = 1, inner_size = 1; for (int i = 0; i < softmax_param_->axis_; i++) { diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/softmax_int8.h b/mindspore/lite/src/runtime/kernel/arm/int8/softmax_int8.h index e652eeaa5f..761a8257b3 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/softmax_int8.h +++ b/mindspore/lite/src/runtime/kernel/arm/int8/softmax_int8.h @@ -28,7 +28,7 @@ class SoftmaxInt8CPUKernel : public SoftmaxBaseCPUKernel { const std::vector &outputs, const lite::InnerContext *ctx, const mindspore::lite::PrimitiveC *primitive) : SoftmaxBaseCPUKernel(parameter, inputs, outputs, ctx, primitive) {} - ~SoftmaxInt8CPUKernel() {} + ~SoftmaxInt8CPUKernel() = default; int Init() override; int ReSize() override; diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/space_to_batch_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/space_to_batch_int8.cc index f58ff57c86..8c81a9bdd3 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/space_to_batch_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/space_to_batch_int8.cc @@ -27,10 +27,15 @@ using mindspore::schema::PrimitiveType_SpaceToBatchND; namespace mindspore::kernel { int SpaceToBatchInt8CPUKernel::Run() { auto input_tensor = in_tensors_.at(0); + MS_ASSERT(input_tensor); auto output_tensor = out_tensors_.at(0); + MS_ASSERT(output_tensor); auto input_ptr = reinterpret_cast(input_tensor->MutableData()); + MS_ASSERT(input_ptr); auto output_ptr = reinterpret_cast(output_tensor->MutableData()); + MS_ASSERT(output_ptr); SpaceToBatchParameter *param = reinterpret_cast(this->op_parameter_); + MS_ASSERT(param); if (output_tensor->quant_params().empty()) { MS_LOG(ERROR) << "SpaceToBatchInt8 need quantization parameters which is not found."; return RET_ERROR; diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/space_to_batch_int8.h b/mindspore/lite/src/runtime/kernel/arm/int8/space_to_batch_int8.h index 13c4635d90..021565f9c1 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/space_to_batch_int8.h +++ b/mindspore/lite/src/runtime/kernel/arm/int8/space_to_batch_int8.h @@ -27,7 +27,7 @@ class SpaceToBatchInt8CPUKernel : public SpaceToBatchCPUKernel { const mindspore::lite::PrimitiveC *primitive) : SpaceToBatchCPUKernel(parameter, inputs, outputs, ctx, primitive) {} - ~SpaceToBatchInt8CPUKernel() {} + ~SpaceToBatchInt8CPUKernel() = default; int Run() override; }; diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/split_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/split_int8.cc index e47df842fd..a4458da10f 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/split_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/split_int8.cc @@ -69,6 +69,8 @@ int SplitInt8CPUKernel::Split(int task_id) { return RET_OK; } int thread_offset = task_id * thread_n_stride_; + MS_ASSERT(input_ptr_); + MS_ASSERT(param); auto ret = Int8DoSplit(input_ptr_, output_ptr_.data(), in_tensors_.front()->shape().data(), thread_offset, num_unit_thread, param); if (ret != RET_OK) { diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/squeeze_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/squeeze_int8.cc index 42f674e5a6..7cbbcda3ae 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/squeeze_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/squeeze_int8.cc @@ -32,55 +32,59 @@ using mindspore::schema::PrimitiveType_Squeeze; namespace mindspore::kernel { -int SqueezeInt8CPUKernel::Init() { - auto init_ret = SqueezeBaseCPUKernel::Init(); - if (init_ret != RET_OK) { - return init_ret; - } - quant_Squeeze_parm_ = new (std::nothrow) SqueezeQuantArg; - if (quant_Squeeze_parm_ == nullptr) { - MS_LOG(ERROR) << "new quant_Squeeze_parm_ failed."; - return RET_ERROR; - } - auto input_num = in_tensors_.size(); - quant_Squeeze_parm_->input_num_ = input_num; - quant_Squeeze_parm_->input_sizes_ = reinterpret_cast(malloc(sizeof(int) * input_num)); - if (quant_Squeeze_parm_->input_sizes_ == nullptr) { - MS_LOG(ERROR) << "Null pointer reference: quant_Squeeze_parm_->input_sizes_."; - return RET_ERROR; +SqueezeInt8CPUKernel::~SqueezeInt8CPUKernel() { + if (quant_squeeze_param_ != nullptr) { + if (quant_squeeze_param_->in_quant_args_ != nullptr) { + free(quant_squeeze_param_->in_quant_args_); + } + if (quant_squeeze_param_->out_quant_args_ != nullptr) { + free(quant_squeeze_param_->out_quant_args_); + } + delete (quant_squeeze_param_); } +} - for (size_t i = 0; i < input_num; i++) { - quant_Squeeze_parm_->input_sizes_[i] = 1; - } - quant_Squeeze_parm_->input_shapes_ = reinterpret_cast(malloc(sizeof(int *) * input_num)); - if (quant_Squeeze_parm_->input_shapes_ == nullptr) { - MS_LOG(ERROR) << "Null pointer reference: quant_Squeeze_parm_->input_shapes_."; +int SqueezeInt8CPUKernel::Init() { + quant_squeeze_param_ = new (std::nothrow) SqueezeQuantArg; + if (quant_squeeze_param_ == nullptr) { + MS_LOG(ERROR) << "new quant_squeeze_param_ failed."; return RET_ERROR; } - quant_Squeeze_parm_->axis_ = 0; - quant_Squeeze_parm_->in_quant_args_ = reinterpret_cast(malloc(sizeof(QuantArg) * input_num)); - if (quant_Squeeze_parm_->in_quant_args_ == nullptr) { - MS_LOG(ERROR) << "Null pointer reference: quant_Squeeze_parm_->in_quant_args_."; + quant_squeeze_param_->in_quant_args_ = reinterpret_cast(malloc(sizeof(QuantArg))); + if (quant_squeeze_param_->in_quant_args_ == nullptr) { + MS_LOG(ERROR) << "Null pointer reference: quant_squeeze_param_->in_quant_args_."; + if (quant_squeeze_param_ != nullptr) { + delete (quant_squeeze_param_); + quant_squeeze_param_ = nullptr; + } return RET_ERROR; } - - for (size_t i = 0; i < input_num; i++) { - auto *input_tensor = in_tensors_.at(i); - auto quant_args = input_tensor->quant_params(); - MS_ASSERT(quant_args.size() == 1); - quant_Squeeze_parm_->in_quant_args_[i].scale_ = quant_args.front().scale; - quant_Squeeze_parm_->in_quant_args_[i].zp_ = quant_args.front().zeroPoint; - } + auto in_quant_args = in_tensors_.front()->quant_params(); + MS_ASSERT(quant_args.size() > 0); + quant_squeeze_param_->in_quant_args_->scale_ = in_quant_args.front().scale; + quant_squeeze_param_->in_quant_args_->zp_ = in_quant_args.front().zeroPoint; MS_ASSERT(this->out_tensors_.size() == 1); auto output_tensor = out_tensors_.at(0); MS_ASSERT(output_tensor != nullptr); auto quant_args = output_tensor->quant_params(); MS_ASSERT(quant_args.size() == 1); - quant_Squeeze_parm_->out_quant_args_.scale_ = quant_args.front().scale; - quant_Squeeze_parm_->out_quant_args_.zp_ = quant_args.front().zeroPoint; + quant_squeeze_param_->out_quant_args_ = reinterpret_cast(malloc(sizeof(QuantArg))); + if (quant_squeeze_param_->in_quant_args_ == nullptr) { + MS_LOG(ERROR) << "malloc QuantArg failed"; + if (quant_squeeze_param_ != nullptr) { + if (quant_squeeze_param_->in_quant_args_ != nullptr) { + free(quant_squeeze_param_->in_quant_args_); + quant_squeeze_param_->in_quant_args_ = nullptr; + } + delete (quant_squeeze_param_); + quant_squeeze_param_ = nullptr; + } + return RET_ERROR; + } + quant_squeeze_param_->out_quant_args_->scale_ = quant_args.front().scale; + quant_squeeze_param_->out_quant_args_->zp_ = quant_args.front().zeroPoint; if (!InferShapeDone()) { return RET_OK; } @@ -88,95 +92,13 @@ int SqueezeInt8CPUKernel::Init() { return ReSize(); } -int SqueezeInt8CPUKernel::ReSize() { - auto input_num = in_tensors_.size(); - for (size_t i = 0; i < input_num; i++) { - auto *input_tensor = in_tensors_.at(i); - MS_ASSERT(input_tensor != nullptr); - auto input_size = input_tensor->shape().size(); - quant_Squeeze_parm_->input_shapes_[i] = reinterpret_cast(malloc(sizeof(int) * input_size)); - if (quant_Squeeze_parm_->input_shapes_[i] == nullptr) { - MS_LOG(ERROR) << "Null pointer reference: quant_Squeeze_parm_->input_shapes_[" << i << "]."; - return RET_ERROR; - } - - ::memcpy(quant_Squeeze_parm_->input_shapes_[i], input_tensor->shape().data(), sizeof(int) * input_size); - for (size_t j = 0; j < input_size; j++) { - auto *input_tensor_tmp = in_tensors_.at(i); - auto input_shape = input_tensor_tmp->shape()[j]; - quant_Squeeze_parm_->input_sizes_[i] *= input_shape; - } - } - - MS_ASSERT(out_tensors_.size() == 1); - auto output_tensor = out_tensors_.at(0); - MS_ASSERT(output_tensor != nullptr); - auto output_shape = output_tensor->shape(); - auto output_dim = output_shape.size(); - quant_Squeeze_parm_->output_dim_ = output_dim; - int output_size = 1; - for (size_t i = 0; i < output_dim; i++) { - output_size *= output_shape[i]; - } - quant_Squeeze_parm_->output_size_ = output_size; - - quant_Squeeze_parm_->output_shape_ = new int[output_size]; - if (quant_Squeeze_parm_->output_shape_ == nullptr) { - MS_LOG(ERROR) << "new quant_Squeeze_parm_->output_shape_ failed."; - return RET_ERROR; - } - ::memcpy(quant_Squeeze_parm_->output_shape_, output_shape.data(), sizeof(int) * output_size); - return RET_OK; -} +int SqueezeInt8CPUKernel::ReSize() { return RET_OK; } int SqueezeInt8CPUKernel::Run() { - auto input_dim = quant_Squeeze_parm_->input_num_; - int8_t **inputs_array = reinterpret_cast(malloc(sizeof(int8_t *) * input_dim)); - if (inputs_array == nullptr) { - MS_LOG(ERROR) << "malloc inputs_array failed."; - return RET_ERROR; - } - for (size_t i = 0; i < input_dim; i++) { - auto input_size = quant_Squeeze_parm_->input_sizes_[i]; - inputs_array[i] = reinterpret_cast(malloc(sizeof(int8_t) * input_size)); - if (inputs_array[i] == nullptr) { - free(inputs_array); - MS_LOG(ERROR) << "malloc inputs_array[" << i << "]" - << " failed."; - return RET_ERROR; - } - auto input_type = in_tensors_[i]->data_type(); - if (input_type == kNumberTypeUInt8) { - uint8_t *input_tmp = reinterpret_cast(in_tensors_[i]->MutableData()); - for (int j = 0; j < input_size; j++) { - inputs_array[i][j] = (int8_t)(input_tmp[j] - 128); - } - for (size_t j = 0; j < input_dim; j++) { - quant_Squeeze_parm_->in_quant_args_[j].zp_ -= 128; - } - quant_Squeeze_parm_->out_quant_args_.zp_ -= 128; - } else { - ::memcpy(inputs_array[i], in_tensors_.at(i)->MutableData(), sizeof(int8_t) * input_size); - } - } - int8_t *output_addr = reinterpret_cast(out_tensors_.at(0)->MutableData()); - auto output_type = out_tensors_[0]->data_type(); - if (output_type == kNumberTypeUInt8) { - auto output_size = quant_Squeeze_parm_->output_size_; - for (int i = 0; i < output_size; i++) { - output_addr[i] = (uint8_t)(output_addr[i] + 128); - } - } - - for (size_t i = 0; i < input_dim; i++) { - free(*(inputs_array + i)); - } - auto ret = ParallelLaunch(this->context_->thread_pool_, SqueezeInt8Run, this, thread_count_); if (ret != RET_OK) { MS_LOG(ERROR) << "RunSqueezeParam failed. errorcode: "; } - free(inputs_array); return ret; } @@ -188,12 +110,16 @@ int SqueezeInt8Run(void *cdata, int task_id) { int SqueezeInt8CPUKernel::DoExecute(int task_id) { auto input_tensor = in_tensors_.at(kInputIndex); + MS_ASSERT(input_tensor); auto out_tensor = out_tensors_.at(kOutputIndex); + MS_ASSERT(out_tensor); int8_t *input_data = reinterpret_cast(input_tensor->MutableData()); + MS_ASSERT(input_data); int8_t *output_data = reinterpret_cast(out_tensor->MutableData()); + MS_ASSERT(output_data); - size_t data_size = in_tensors_.front()->Size(); - Squeeze(&input_data, output_data, task_id, quant_Squeeze_parm_, para_, data_size); + int num = input_tensor->ElementsNum(); + SqueezeInt8(input_data, output_data, task_id, quant_squeeze_param_, para_, num); return RET_OK; } kernel::LiteKernel *CpuSqueezeInt8KernelCreator(const std::vector &inputs, diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/squeeze_int8.h b/mindspore/lite/src/runtime/kernel/arm/int8/squeeze_int8.h index fb18ab405d..5128a3825e 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/squeeze_int8.h +++ b/mindspore/lite/src/runtime/kernel/arm/int8/squeeze_int8.h @@ -34,7 +34,7 @@ class SqueezeInt8CPUKernel : public SqueezeBaseCPUKernel { : SqueezeBaseCPUKernel(parameter, inputs, outputs, ctx, primitive) { para_ = reinterpret_cast(parameter); } - ~SqueezeInt8CPUKernel() override { delete quant_Squeeze_parm_; } + ~SqueezeInt8CPUKernel() override; int Init() override; int ReSize() override; @@ -43,7 +43,7 @@ class SqueezeInt8CPUKernel : public SqueezeBaseCPUKernel { private: SqueezeParameter *para_; - SqueezeQuantArg *quant_Squeeze_parm_; + SqueezeQuantArg *quant_squeeze_param_; }; int SqueezeInt8Run(void *cdata, int task_id); diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/sub_int8.h b/mindspore/lite/src/runtime/kernel/arm/int8/sub_int8.h index 2f52314c2f..1a1e632dc0 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/sub_int8.h +++ b/mindspore/lite/src/runtime/kernel/arm/int8/sub_int8.h @@ -28,7 +28,7 @@ class SubInt8CPUKernel : public LiteKernel { const std::vector &outputs, const lite::InnerContext *ctx, const mindspore::lite::PrimitiveC *primitive) : LiteKernel(parameter, inputs, outputs, ctx, primitive) {} - ~SubInt8CPUKernel() override {} + ~SubInt8CPUKernel() = default; int Init() override; int ReSize() override; diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/topk_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/topk_int8.cc index 530a789699..45529827a3 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/topk_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/topk_int8.cc @@ -33,11 +33,9 @@ int TopKInt8CPUKernel::Init() { int TopKInt8CPUKernel::ReSize() { TopkParameter *parameter = reinterpret_cast(op_parameter_); - if (parameter->topk_node_list_ != nullptr) { - free(parameter->topk_node_list_); - parameter->topk_node_list_ = nullptr; - } + MS_ASSERT(parameter); lite::Tensor *input = in_tensors_.at(0); + MS_ASSERT(input); parameter->last_dim_size_ = input->shape()[input->shape().size() - 1]; parameter->loop_num_ = 1; for (size_t i = 0; i < input->shape().size() - 1; ++i) { @@ -48,8 +46,11 @@ int TopKInt8CPUKernel::ReSize() { int TopKInt8CPUKernel::Run() { int8_t *input_data = reinterpret_cast(in_tensors_.at(0)->MutableData()); + MS_ASSERT(input_data); int8_t *output_data = reinterpret_cast(out_tensors_.at(0)->MutableData()); + MS_ASSERT(output_data); int32_t *output_index = reinterpret_cast(out_tensors_.at(1)->MutableData()); + MS_ASSERT(output_index); MS_ASSERT(context_->allocator != nullptr); TopkParameter *parameter = reinterpret_cast(op_parameter_); diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/topk_int8.h b/mindspore/lite/src/runtime/kernel/arm/int8/topk_int8.h index 2c4892cc30..2f62e569f8 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/topk_int8.h +++ b/mindspore/lite/src/runtime/kernel/arm/int8/topk_int8.h @@ -30,13 +30,7 @@ class TopKInt8CPUKernel : public LiteKernel { TopkParameter *param = reinterpret_cast(op_parameter_); param->topk_node_list_ = nullptr; } - ~TopKInt8CPUKernel() override { - TopkParameter *parameter = reinterpret_cast(op_parameter_); - if (parameter->topk_node_list_ != nullptr) { - free(parameter->topk_node_list_); - parameter->topk_node_list_ = nullptr; - } - } + ~TopKInt8CPUKernel() = default; int Init() override; int ReSize() override; diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/transpose_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/transpose_int8.cc index dc0ed42491..a0036a3b21 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/transpose_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/transpose_int8.cc @@ -25,8 +25,6 @@ using mindspore::schema::PrimitiveType_Transpose; namespace mindspore::kernel { -TransposeInt8CPUKernel::~TransposeInt8CPUKernel() { return; } - int TransposeInt8CPUKernel::Init() { if (!InferShapeDone()) { return RET_OK; @@ -114,10 +112,17 @@ int TransposeInt8CPUKernel::DoTranspose(int task_id) { int *dim_size = nullptr; int *position = nullptr; if (extra_dims_) { + MS_ASSERT(dim_size_); dim_size = dim_size_ + task_id * transpose_param_->num_axes_; + MS_ASSERT(position_); position = position_ + task_id * transpose_param_->num_axes_; } + MS_ASSERT(in_ptr_); + MS_ASSERT(out_ptr_); + MS_ASSERT(in_shape_); + MS_ASSERT(out_shape_); + MS_ASSERT(transpose_param_); auto ret = DoTransposeInt8(in_ptr_, out_ptr_, out_shape_, transpose_param_, thread_offset, thread_offset + num_unit_thread, dim_size, position); if (ret != RET_OK) { diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/transpose_int8.h b/mindspore/lite/src/runtime/kernel/arm/int8/transpose_int8.h index 18d3fb9899..05d1306765 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/transpose_int8.h +++ b/mindspore/lite/src/runtime/kernel/arm/int8/transpose_int8.h @@ -31,7 +31,7 @@ class TransposeInt8CPUKernel : public LiteKernel { : LiteKernel(parameter, inputs, outputs, ctx, primitive) { transpose_param_ = reinterpret_cast(op_parameter_); } - ~TransposeInt8CPUKernel() override; + ~TransposeInt8CPUKernel() = default; int Init() override; int ReSize() override; diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/unsqueeze_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/unsqueeze_int8.cc index 8dae1551c8..c0d14b2c98 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/unsqueeze_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/unsqueeze_int8.cc @@ -32,13 +32,13 @@ int Unsqueezeint8CPUKernel::Init() { auto *input_tensor = in_tensors_.at(0); auto quant_args = input_tensor->quant_params(); MS_ASSERT(quant_args.size() == 1); - Unsq_para_->quant_arg.in_quant_args_.scale_ = quant_args.front().scale; - Unsq_para_->quant_arg.in_quant_args_.zp_ = quant_args.front().zeroPoint; + param_->quant_arg.in_quant_args_.scale_ = quant_args.front().scale; + param_->quant_arg.in_quant_args_.zp_ = quant_args.front().zeroPoint; auto out_quant_args = input_tensor->quant_params(); - Unsq_para_->quant_arg.out_quant_args_.scale_ = out_quant_args.front().scale; - Unsq_para_->quant_arg.out_quant_args_.zp_ = out_quant_args.front().zeroPoint; - Unsq_para_->thread_count_ = thread_count_; + param_->quant_arg.out_quant_args_.scale_ = out_quant_args.front().scale; + param_->quant_arg.out_quant_args_.zp_ = out_quant_args.front().zeroPoint; + param_->thread_count_ = thread_count_; if (!InferShapeDone()) { return RET_OK; } @@ -59,10 +59,12 @@ int Unsqueezeint8CPUKernel::DoUnsqueeze(int task_id) { } auto input_ptr = reinterpret_cast(in_tensors_.front()->MutableData()); + MS_ASSERT(input_ptr); auto output_ptr = reinterpret_cast(out_tensors_.front()->MutableData()); + MS_ASSERT(output_ptr); size_t data_size = out_tensors_.front()->Size(); - int ret = Int8Unsqueeze(input_ptr, output_ptr, Unsq_para_, data_size, task_id); + int ret = Int8Unsqueeze(input_ptr, output_ptr, param_, data_size, task_id); if (ret != RET_OK) { MS_LOG(ERROR) << "UnsqueezeRun error task_id[" << task_id << "] error_code[" << ret << "]"; return ret; diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/unsqueeze_int8.h b/mindspore/lite/src/runtime/kernel/arm/int8/unsqueeze_int8.h index 88b350b3d2..f411d6c20e 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/unsqueeze_int8.h +++ b/mindspore/lite/src/runtime/kernel/arm/int8/unsqueeze_int8.h @@ -31,8 +31,8 @@ class Unsqueezeint8CPUKernel : public LiteKernel { const std::vector &outputs, const InnerContext *ctx, const mindspore::lite::PrimitiveC *primitive) : LiteKernel(parameter, inputs, outputs, ctx, primitive), thread_count_(ctx->thread_num_) { - Unsq_para_ = reinterpret_cast(op_parameter_); - Unsq_para_->thread_count_ = op_parameter_->thread_num_; + param_ = reinterpret_cast(op_parameter_); + param_->thread_count_ = op_parameter_->thread_num_; } ~Unsqueezeint8CPUKernel() = default; @@ -42,7 +42,7 @@ class Unsqueezeint8CPUKernel : public LiteKernel { int DoUnsqueeze(int task_id); private: - UnSqueezeParameter *Unsq_para_; + UnSqueezeParameter *param_; int thread_sz_count_; int thread_sz_stride_; int data_size_;