Nigel
/
mindspore
forked from mindspore-Ecosystem/mindspore
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

!41230 [MSLITE][CPU][r1.8] code clean 

Merge pull request !41230 from Greatpan/code_clean_r1.8_2
This commit is contained in:
i-robot 2022-09-01 05:55:07 +00:00 committed by Gitee
parent e819545cd5 9b275dad66
commit 14ee7630fd
No known key found for this signature in database
GPG Key ID: 173E9B9CA92EEF8F
9 changed files with 66 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
mindspore/lite/src/runtime/kernel/cpu/fp32/local_response_norm_fp32.cc
View File

@ -53,10 +53,10 @@ int LocalResponseNormCPUKernel::DoLocalResponseNorm(int task_id) const {
auto in_shape = input_tensor->shape();
MS_CHECK_TRUE_RET(in_shape.size() == C4NUM, RET_ERROR);
int batch = in_shape.at(0);
int height = in_shape.at(1);
int width = in_shape.at(2);
int channel = in_shape.at(3);
int batch = in_shape.at(kNHWC_N);
int height = in_shape.at(kNHWC_H);
int width = in_shape.at(kNHWC_W);
int channel = in_shape.at(kNHWC_C);
int outer_size = batch * width * height;
MS_CHECK_TRUE_RET(thread_count_ != 0, RET_ERROR);

19
mindspore/lite/src/runtime/kernel/cpu/fp32/lstm_fp32.cc
View File

@ -31,6 +31,11 @@ using mindspore::lite::RET_OK;
using mindspore::schema::PrimitiveType_LSTM;
namespace mindspore::kernel {
namespace {
constexpr int kOutputHiddenStatusIndex = 1;
constexpr int kOutputCellStatusIndex = 2;
} // namespace
int LstmInputMulWeightRun(void *cdata, int task_id, float, float) {
auto kernel = reinterpret_cast<const LstmCPUKernel *>(cdata);
CHECK_NULL_RETURN(kernel);
@ -93,7 +98,7 @@ int LstmCPUKernel::InitInputWeightBias() {
int offset = weight_batch_ * (cw_size + hh_size);
float *bias_data = (has_bias) ? weight_i_data + offset : nullptr;
int dir_mul = lstm_param_->bidirectional_ ? 2 : 1;
int dir_mul = lstm_param_->bidirectional_ ? C2NUM : C1NUM;
int b_stride = (gpu_orig_state_) ? gate_num * (dir_mul * b_size) : gate_num * (b_size);
if (in_tensors_.size() > mindir_input_tensors) {
bias_data = reinterpret_cast<float *>(in_tensors_.at(onnx_bias_index)->data());
@ -209,9 +214,9 @@ int LstmCPUKernel::InitParam() {
} else {
lstm_param_->hidden_size_ = w_shape.at(SECOND_INPUT) / gate_num;
}
lstm_param_->output_step_ = lstm_param_->bidirectional_ ? 2 * lstm_param_->batch_ * lstm_param_->hidden_size_
lstm_param_->output_step_ = lstm_param_->bidirectional_ ? C2NUM * lstm_param_->batch_ * lstm_param_->hidden_size_
: lstm_param_->batch_ * lstm_param_->hidden_size_;
weight_batch_ = lstm_param_->bidirectional_ ? 2 * gate_num : gate_num;
weight_batch_ = lstm_param_->bidirectional_ ? C2NUM * gate_num : gate_num;
state_is_vec_ = lstm_param_->batch_ == 1;
// determine FB origin
gpu_orig_state_ = false;
@ -428,8 +433,8 @@ void LstmCPUKernel::LstmUnidirectional(float *output, const float *weight_h, con
float *buffer[], bool is_backward) {
float *gate = buffer[input_gate_index];
float *input_gate = gate;
float *forget_gate = gate + lstm_param_->seq_len_ * lstm_param_->batch_ * lstm_param_->hidden_size_ * 2;
float *cell_gate = gate + lstm_param_->seq_len_ * lstm_param_->batch_ * lstm_param_->hidden_size_ * 3;
float *forget_gate = gate + lstm_param_->seq_len_ * lstm_param_->batch_ * lstm_param_->hidden_size_ * C2NUM;
float *cell_gate = gate + lstm_param_->seq_len_ * lstm_param_->batch_ * lstm_param_->hidden_size_ * C3NUM;
float *output_gate = gate + lstm_param_->seq_len_ * lstm_param_->batch_ * lstm_param_->hidden_size_;
float *tmp = buffer[tmp_hidden_output_index];
int dir_mult = lstm_param_->bidirectional_ ? C2NUM : C1NUM;
@ -568,10 +573,10 @@ int LstmCPUKernel::Run() {
auto cell_state = in_tensors_.at(cell_state_input_index_);
CHECK_NULL_RETURN(cell_state->data());
auto output_hidden_state = out_tensors_[1];
auto output_hidden_state = out_tensors_[kOutputHiddenStatusIndex];
CHECK_NULL_RETURN(output_hidden_state->data());
(void)memcpy(output_hidden_state->data(), hidden_state->data(), hidden_state->ElementsNum() * sizeof(float));
auto output_cell_state = out_tensors_[2];
auto output_cell_state = out_tensors_[kOutputCellStatusIndex];
CHECK_NULL_RETURN(output_cell_state->data());
(void)memcpy(output_cell_state->data(), cell_state->data(), cell_state->ElementsNum() * sizeof(float));

2
mindspore/lite/src/runtime/kernel/cpu/fp32/nonzero_fp32.cc
View File

@ -47,7 +47,7 @@ int NonZeroCPUKernel::Run() {
CHECK_NULL_RETURN(input_data);
CHECK_NULL_RETURN(output_data);
auto input_dim_size = in_tensor->shape().size();
if (out_tensor->shape().size() != 2) {
if (out_tensor->shape().size() != C2NUM) {
MS_LOG(ERROR) << "out tensor shape size must be equal to 2!";
return RET_ERROR;
}

28
mindspore/lite/src/runtime/kernel/cpu/fp32/pad_fp32.cc
View File

@ -97,7 +97,7 @@ void PadCPUKernel::InitMirrorPadBlock() {
mirror_pad_block_.clear();
std::vector<int> left_pads(DEFAULT_PAD_NDIMS);
for (size_t i = 0; i < DEFAULT_PAD_NDIMS; ++i) {
left_pads[i] = pad_param_->paddings_[2 * i];
left_pads[i] = pad_param_->paddings_[C2NUM * i];
}
std::vector<int> input_separate_dims;
std::vector<int> output_separate_dims;
@ -160,17 +160,17 @@ void PadCPUKernel::InitMirrorPadBlock() {
continue;
}
switch (pad_cord[i]) {
case 0:
case C0NUM:
dst_offset += separate_offset[si] * output_separate_stride[si];
block.size_[di] = input_separate_dims[si];
block.out_stride_[di] = output_separate_stride[si];
break;
case 2:
case C2NUM:
dst_offset += (separate_offset[si] + input_separate_dims[si]) * output_separate_stride[si];
block.size_[di] = right_pads[si];
block.out_stride_[di] = output_separate_stride[si];
break;
case 1:
case C1NUM:
if (separate_offset[si] > 0) {
block.size_[di] = separate_offset[si];
block.out_stride_[di] = output_separate_stride[si];
@ -312,12 +312,12 @@ int PadCPUKernel::CheckPaddings(const int *paddings, int length, const int *inpu
}
for (auto i = 0; i < length; ++i) {
int max_valid = input_shape[i] - offset;
if (paddings[i * 2] > max_valid) {
MS_LOG(WARNING) << prefix << "paddings " << paddings[i * 2] << " should be less than " << max_valid + 1;
if (paddings[i * C2NUM] > max_valid) {
MS_LOG(WARNING) << prefix << "paddings " << paddings[i * C2NUM] << " should be less than " << max_valid + 1;
MS_LOG(WARNING) << "Running mirror pad with padding bigger than shape.";
}
if (paddings[i * 2 + 1] > max_valid) {
MS_LOG(WARNING) << prefix << "paddings " << paddings[i * 2 + 1] << " should be less than " << max_valid + 1;
if (paddings[i * C2NUM + 1] > max_valid) {
MS_LOG(WARNING) << prefix << "paddings " << paddings[i * C2NUM + 1] << " should be less than " << max_valid + 1;
MS_LOG(WARNING) << "Running mirror pad with padding bigger than shape.";
}
}
@ -334,8 +334,8 @@ int PadCPUKernel::CopyPaddingFromInput() {
CHECK_NULL_RETURN(paddings);
auto input_shape = in_tensors_.at(0)->shape();
int rank = static_cast<int>(input_shape.size());
if (padding_tensor->ElementsNum() != rank * 2) {
MS_LOG(ERROR) << "Pad second input elements num" << padding_tensor->ElementsNum() << ", should be " << rank * 2;
if (padding_tensor->ElementsNum() != rank * C2NUM) {
MS_LOG(ERROR) << "Pad second input elements num" << padding_tensor->ElementsNum() << ", should be " << rank * C2NUM;
return RET_ERROR;
}
@ -353,14 +353,14 @@ int PadCPUKernel::CopyPaddingFromInput() {
void PadCPUKernel::CalculateStrides() {
pad_param_->in_strides[DEFAULT_PAD_NDIMS - 1] = 1;
for (auto i = DEFAULT_PAD_NDIMS - 2; i >= 0; --i) {
for (auto i = DEFAULT_PAD_NDIMS - C2NUM; i >= 0; --i) {
pad_param_->in_strides[i] = in_[i + 1] * pad_param_->in_strides[i + 1];
}
for (auto i = 0; i < DEFAULT_PAD_NDIMS; ++i) {
out_[i] = in_[i] + pad_param_->paddings_[i * 2] + pad_param_->paddings_[i * 2 + 1];
out_[i] = in_[i] + pad_param_->paddings_[i * C2NUM] + pad_param_->paddings_[i * C2NUM + 1];
}
pad_param_->out_strides[DEFAULT_PAD_NDIMS - 1] = 1;
for (auto i = DEFAULT_PAD_NDIMS - 2; i >= 0; --i) {
for (auto i = DEFAULT_PAD_NDIMS - C2NUM; i >= 0; --i) {
pad_param_->out_strides[i] = out_[i + 1] * pad_param_->out_strides[i + 1];
}
}
@ -393,7 +393,7 @@ int PadCPUKernel::HandleMirrorPad() {
int PadCPUKernel::Run() {
if (in_tensors_.size() == kInputSize2) {
auto pad_value = in_tensors_.at(2);
auto pad_value = in_tensors_.at(kPadCommonInputSize);
auto value_num = pad_value->ElementsNum();
if (value_num != 1) {
MS_LOG(ERROR) << "The number of padding value should be only one, but got " << value_num;

31
mindspore/lite/src/runtime/kernel/cpu/fp32/relative_position_attention_fp32.cc
View File

@ -30,6 +30,7 @@ namespace mindspore::kernel {
RelativePositionAttentionCPUKernel::~RelativePositionAttentionCPUKernel() { FreeAllPackData(); }
namespace {
constexpr int kWeightQTensorIndex = 4;
constexpr int kActivationTensorShapeSize = 3;
constexpr int kActivationTensorBatch = 1;
constexpr int kTensorShapeBatchIndex = 0;
@ -58,18 +59,18 @@ int RelativePositionAttentionCPUKernel::CheckInputs() {
MS_LOG(ERROR) << "input_k is abnormal.";
return RET_ERROR;
}
input_v_tensor_ = this->in_tensors_.at(2);
input_v_tensor_ = this->in_tensors_.at(k3DimsLeftMatrixDeepIndex);
if (!AttentionActivationTensorCheck(input_v_tensor_)) {
MS_LOG(ERROR) << "input_v is abnormal.";
return RET_ERROR;
}
input_p_tensor_ = this->in_tensors_.at(3);
input_p_tensor_ = this->in_tensors_.at(kActivationTensorShapeSize);
if (!AttentionActivationTensorCheck(input_p_tensor_)) {
MS_LOG(ERROR) << "input_p is abnormal.";
return RET_ERROR;
}
// Sequence length Q / 2 should be equal to sequence length of K
if (input_p_tensor_->shape().at(1) / 2 != input_k_tensor_->shape().at(1)) {
if (input_p_tensor_->shape().at(1) / C2NUM != input_k_tensor_->shape().at(1)) {
MS_LOG(ERROR) << "Sequence length of input_p / 2 != sequence length of input_k";
return RET_ERROR;
}
@ -109,37 +110,37 @@ bool AttentionWeightTensorCheck(const lite::Tensor *tensor) {
} // namespace
int RelativePositionAttentionCPUKernel::CheckWeights() {
weight_q_tensor_ = this->in_tensors_.at(4);
weight_q_tensor_ = this->in_tensors_.at(kWeightQTensorIndex);
if (!AttentionWeightTensorCheck(weight_q_tensor_)) {
MS_LOG(ERROR) << "weight_q is abnormal.";
return RET_ERROR;
}
weight_k_tensor_ = this->in_tensors_.at(5);
weight_k_tensor_ = this->in_tensors_.at(5); // inputs: 5:WK
if (!AttentionWeightTensorCheck(weight_k_tensor_)) {
MS_LOG(ERROR) << "weight_k is abnormal.";
return RET_ERROR;
}
weight_v_tensor_ = this->in_tensors_.at(6);
weight_v_tensor_ = this->in_tensors_.at(6); // inputs: 6:WV
if (!AttentionWeightTensorCheck(weight_v_tensor_)) {
MS_LOG(ERROR) << "weight_v is abnormal.";
return RET_ERROR;
}
weight_p_tensor_ = this->in_tensors_.at(7);
weight_p_tensor_ = this->in_tensors_.at(7); // inputs: 7:WP
if (!AttentionWeightTensorCheck(weight_p_tensor_)) {
MS_LOG(ERROR) << "weight_p is abnormal.";
return RET_ERROR;
}
pos_u_tensor_ = this->in_tensors_.at(8);
pos_u_tensor_ = this->in_tensors_.at(8); // inputs: 8:PU
if (!AttentionWeightTensorCheck(pos_u_tensor_)) {
MS_LOG(ERROR) << "pos_u is abnormal.";
return RET_ERROR;
}
pos_v_tensor_ = this->in_tensors_.at(9);
pos_v_tensor_ = this->in_tensors_.at(9); // inputs: 9:PV
if (!AttentionWeightTensorCheck(pos_v_tensor_)) {
MS_LOG(ERROR) << "pos_v is abnormal.";
return RET_ERROR;
}
weight_o_tensor_ = this->in_tensors_.at(10);
weight_o_tensor_ = this->in_tensors_.at(10); // inputs: 10:WO
if (!AttentionWeightTensorCheck(weight_o_tensor_)) {
MS_LOG(ERROR) << "weight_o is abnormal.";
return RET_ERROR;
@ -168,10 +169,10 @@ int RelativePositionAttentionCPUKernel::CheckBiases() {
if (!param_->use_bias_) {
return RET_OK;
}
bias_q_tensor_ = this->in_tensors_.at(11);
bias_k_tensor_ = this->in_tensors_.at(12);
bias_v_tensor_ = this->in_tensors_.at(13);
bias_o_tensor_ = this->in_tensors_.at(14);
bias_q_tensor_ = this->in_tensors_.at(11); // inputs : 11:BQ
bias_k_tensor_ = this->in_tensors_.at(12); // inputs : 12:BK
bias_v_tensor_ = this->in_tensors_.at(13); // inputs : 13:BV
bias_o_tensor_ = this->in_tensors_.at(14); // inputs : 14:BO
if (!AttentionBiasTensorCheck(bias_q_tensor_)) {
MS_LOG(ERROR) << "bias_q is abnormal.";
return RET_ERROR;
@ -536,7 +537,7 @@ int RelativePositionAttentionCPUKernel::PackRunBuffersLogits(int batch, int num_
return RET_ERROR;
}
// relative shift output shape is [batch * num_heads, q_seq, p_seq / 2]
(void)InitMatrix(&logits_with_v_shifted_mat_, batch * num_heads, param_->q_seq_, param_->p_seq_ / 2, false);
(void)InitMatrix(&logits_with_v_shifted_mat_, batch * num_heads, param_->q_seq_, param_->p_seq_ / C2NUM, false);
ret = MallocLeftTensor(&logits_with_v_shifted_mat_, param_->row_tile_, ms_context_->allocator, false);
if (ret != RET_OK) {
MS_LOG(ERROR) << "Malloc logits_with_v_shifted buffer failed";

16
mindspore/lite/src/runtime/kernel/cpu/fp32/resize_fp32.cc
View File

@ -59,8 +59,8 @@ int ResizeCPUKernel::ReSize() {
}
if (!const_shape_) {
new_height_ = out_tensors_.at(0)->shape()[1];
new_width_ = out_tensors_.at(0)->shape()[2];
new_height_ = out_tensors_.at(0)->shape()[kNHWC_H];
new_width_ = out_tensors_.at(0)->shape()[kNHWC_W];
}
auto ret = MallocTmpBuffer();
@ -95,10 +95,10 @@ void ResizeCPUKernel::CalTmpBufferLen(int *x_len, int *y_len, int *x_weight_len,
*y_weight_len = new_height_;
}
if (method_ == static_cast<int>(schema::ResizeMethod_CUBIC)) {
*x_len = new_width_ * 4;
*y_len = new_height_ * 4;
*x_weight_len = new_width_ * 4;
*y_weight_len = new_height_ * 4;
*x_len = new_width_ * C4NUM;
*y_len = new_height_ * C4NUM;
*x_weight_len = new_width_ * C4NUM;
*y_weight_len = new_height_ * C4NUM;
}
}
@ -191,10 +191,10 @@ int ResizeCPUKernel::RunImpl(int task_id) {
int unit = UP_DIV(new_height_, op_parameter_->thread_num_);
int h_begin = unit * task_id;
int h_end = std::min(h_begin + unit, new_height_);
int c = input_shape.at(3);
int c = input_shape.at(kNHWC_C);
switch (method_) {
case static_cast<int>(schema::ResizeMethod_LINEAR): {
float *line0 = static_cast<float *>(line_buffer_) + new_width_ * c * 2 * task_id;
float *line0 = static_cast<float *>(line_buffer_) + new_width_ * c * C2NUM * task_id;
float *line1 = line0 + new_width_ * c;
return ResizeBilinear(input_data, output_data, input_shape.data(), out_tensors_.at(0)->shape().data(),
coordinate_.y_bottoms_, coordinate_.y_tops_, coordinate_.x_lefts_, coordinate_.x_rights_,

18
mindspore/lite/src/runtime/kernel/cpu/fp32/roi_pooling_fp32.cc
View File

@ -57,17 +57,17 @@ int ROIPoolingCPUKernel::ReSize() {
return RET_ERROR;
}
param_->ndim_ = ndims;
param_->input_n_ = in_shape.at(0);
param_->input_h_ = in_shape.at(1);
param_->input_w_ = in_shape.at(2);
param_->input_c_ = in_shape.at(3);
param_->output_n_ = out_shape.at(0);
param_->output_h_ = out_shape.at(1);
param_->output_w_ = out_shape.at(2);
param_->output_c_ = out_shape.at(3);
param_->input_n_ = in_shape.at(kNHWC_N);
param_->input_h_ = in_shape.at(kNHWC_H);
param_->input_w_ = in_shape.at(kNHWC_W);
param_->input_c_ = in_shape.at(kNHWC_C);
param_->output_n_ = out_shape.at(kNHWC_N);
param_->output_h_ = out_shape.at(kNHWC_H);
param_->output_w_ = out_shape.at(kNHWC_W);
param_->output_c_ = out_shape.at(kNHWC_C);
param_->in_strides_[ndims - 1] = 1;
param_->out_strides_[ndims - 1] = 1;
for (int i = ndims - 2; i >= 0; --i) {
for (int i = ndims - C2NUM; i >= 0; --i) {
param_->in_strides_[i] = in_shape.at(i + 1) * param_->in_strides_[i + 1];
param_->out_strides_[i] = out_shape.at(i + 1) * param_->out_strides_[i + 1];
}

2
mindspore/lite/src/runtime/kernel/cpu/fp32/topk_fp32.cc
View File

@ -56,7 +56,7 @@ int TopKCPUKernel::Run() {
auto output_index = reinterpret_cast<int32_t *>(out_tensors_.at(1)->data());
CHECK_NULL_RETURN(output_index);
if (in_tensors_.size() == 2) {
if (in_tensors_.size() == C2NUM) {
auto input_k = reinterpret_cast<int *>(in_tensors_.at(1)->data());
CHECK_NULL_RETURN(input_k);
topk_param_->k_ = input_k[0];

2
mindspore/lite/src/runtime/kernel/cpu/fp32/where_fp32.cc
View File

@ -155,7 +155,7 @@ int WhereCPUKernel::RunWithTripleInputs() {
CHECK_NULL_RETURN(condition);
auto x = in_tensors_.at(1);
CHECK_NULL_RETURN(x);
auto y = in_tensors_.at(2);
auto y = in_tensors_.at(C2NUM);
CHECK_NULL_RETURN(y);
int condition_nums = condition->ElementsNum();
int x_num = x->ElementsNum();