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

fix bot engine cxx

This commit is contained in:
yangjie159 2021-06-04 14:37:30 +08:00
parent 475386e338
commit 326f8c836f
28 changed files with 27 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/softmax_int8_coder.cc
View File

@ -21,7 +21,6 @@
using mindspore::schema::PrimitiveType_Softmax;
namespace mindspore::lite::micro::cmsis {
int SoftMaxInt8Coder::Prepare(CoderContext *const context) {
SoftmaxBaseCoder::Init();
@ -51,7 +50,7 @@ int SoftMaxInt8Coder::Prepare(CoderContext *const context) {
const int trailing_dim = static_cast<int>(input_tensor_->shape().size()) - 1;
const int dims_count = input_tensor_->shape().size();
MS_CHECK_TRUE(0 <= trailing_dim && trailing_dim < dims_count, "trailing_dim should be in [0, dims_count)");
MS_CHECK_TRUE(trailing_dim >= 0 && trailing_dim < dims_count, "trailing_dim should be in [0, dims_count)");
num_rows_ = 1;
for (int i = 0; i < dims_count; ++i) {
num_rows_ *= (i == trailing_dim) ? 1 : input_tensor_->DimensionSize(i);
@ -77,11 +76,9 @@ int SoftMaxInt8Coder::DoCode(CoderContext *const context) {
"arm_softmax_s8.c",
});
code.CodeFunction("arm_softmax_s8", input_tensor_, num_rows_, row_size_, mult_, shift_, diff_min_, output_tensor_);
MS_LOG(INFO) << "SoftMaxInt8Coder has been called";
context->AppendCode(code.str());
return RET_OK;
}
REG_OPERATOR_CODER(kARM32M, kNumberTypeInt8, PrimitiveType_Softmax, CPUOpCoderCreator<SoftMaxInt8Coder>)
} // namespace mindspore::lite::micro::cmsis

4
mindspore/lite/micro/coder/opcoders/nnacl/dequant/de_quant.cc
View File

@ -19,9 +19,9 @@
#include <vector>
#include "coder/opcoders/serializers/nnacl_serializer/nnacl_fp32_serializer.h"
static constexpr int kPerTensor = 1;
static constexpr size_t kPerBatch = 3;
namespace mindspore::lite::micro::nnacl {
constexpr int kPerTensor = 1;
constexpr size_t kPerBatch = 3;
void Dequant::set_de_quant_buffer_str(const std::string &dequant_buffer_str) {
de_quant_buffer_str_ = "(float *)(" + dequant_buffer_str + ")";

2
mindspore/lite/micro/coder/opcoders/nnacl/fp32/activation_fp32_coder.cc
View File

@ -24,7 +24,6 @@
using mindspore::schema::PrimitiveType_Activation;
namespace mindspore::lite::micro::nnacl {
int ActivationFP32Coder::DoCode(CoderContext *const context) {
// attribute
auto *activation_parameter = reinterpret_cast<ActivationParameter *>(parameter_);
@ -32,7 +31,6 @@ int ActivationFP32Coder::DoCode(CoderContext *const context) {
MS_CHECK_TRUE(thread_num_ > 0, "thread_num_ <= 0");
int stride = UP_DIV(length, thread_num_);
int count = MSMIN(stride, length - stride * kDefaultTaskId);
Collect(context,
{
"nnacl/fp32/activation_fp32.h",

2
mindspore/lite/micro/coder/opcoders/nnacl/fp32/addn_fp32_coder.cc
View File

@ -21,7 +21,6 @@
using mindspore::schema::PrimitiveType_AddN;
namespace mindspore::lite::micro::nnacl {
int AddNFP32Coder::DoCode(CoderContext *const context) {
Tensor *input0 = input_tensors_.at(kInputIndex);
Tensor *input1 = input_tensors_.at(1);
@ -49,5 +48,4 @@ int AddNFP32Coder::DoCode(CoderContext *const context) {
}
REG_OPERATOR_CODER(kAllTargets, kNumberTypeFloat32, PrimitiveType_AddN, CPUOpCoderCreator<AddNFP32Coder>)
} // namespace mindspore::lite::micro::nnacl

2
mindspore/lite/micro/coder/opcoders/nnacl/fp32/arithmetic_fp32_coder.cc
View File

@ -21,7 +21,6 @@
#include "coder/log.h"
namespace mindspore::lite::micro::nnacl {
namespace {
std::string wrap_void(const std::string &a) { return "(void *)(" + a + ")"; }
std::string wrap_uint8(const std::string &a) { return "(uint8_t *)(" + a + ")"; }
@ -370,7 +369,6 @@ int ArithmeticFP32Coder::BatchScalarCalc(int task_id, CoderContext *const contex
int out_offset = out_stride * start_batch;
arithmetic_wrapper_info_ = {offset0, stride0, offset1, stride1, out_offset, out_stride, arithmetic_func_type_};
code->CodeStruct("arithmetic_wrapper_info", arithmetic_wrapper_info_);
code->CodeStruct("arithmetic_parameter", *arithmetic_parameter_);
code->CodeFunction("BatchScalarCalc", wrap_uint8(input0_ptr_str_), wrap_uint8(input1_ptr_str_),

2
mindspore/lite/micro/coder/opcoders/nnacl/fp32/arithmetic_self_fp32_coder.cc
View File

@ -23,7 +23,6 @@
#include "coder/opcoders/parallel.h"
namespace mindspore::lite::micro::nnacl {
int ArithmeticSelfFP32Coder::ReSize() {
data_size_ = input_tensor_->ElementsNum();
thread_sz_count_ = MSMIN(thread_num_, static_cast<int>(data_size_));
@ -109,5 +108,4 @@ REG_OPERATOR_CODER(kAllTargets, kNumberTypeFloat32, PrimitiveType_Round, CPUOpCo
REG_OPERATOR_CODER(kAllTargets, kNumberTypeFloat32, PrimitiveType_Neg, CPUOpCoderCreator<ArithmeticSelfFP32Coder>)
REG_OPERATOR_CODER(kAllTargets, kNumberTypeFloat32, PrimitiveType_Erf, CPUOpCoderCreator<ArithmeticSelfFP32Coder>)
} // namespace mindspore::lite::micro::nnacl

2
mindspore/lite/micro/coder/opcoders/nnacl/fp32/assign_add_fp32_coder.cc
View File

@ -20,7 +20,6 @@
#include "coder/opcoders/serializers/nnacl_serializer/nnacl_fp32_serializer.h"
namespace mindspore::lite::micro::nnacl {
using mindspore::schema::PrimitiveType_AssignAdd;
int AssignAddFP32Coder::Prepare(CoderContext *const context) { return RET_OK; }
@ -51,5 +50,4 @@ int AssignAddFP32Coder::DoCode(CoderContext *const context) {
REG_OPERATOR_CODER(kAllTargets, kNumberTypeFloat32, PrimitiveType_AssignAdd, CPUOpCoderCreator<AssignAddFP32Coder>)
REG_OPERATOR_CODER(kAllTargets, kNumberTypeInt32, PrimitiveType_AssignAdd, CPUOpCoderCreator<AssignAddFP32Coder>)
} // namespace mindspore::lite::micro::nnacl

5
mindspore/lite/micro/coder/opcoders/nnacl/fp32/batchnorm_fp32_coder.cc
View File

@ -25,7 +25,6 @@
using mindspore::schema::PrimitiveType_BatchNorm;
namespace mindspore::lite::micro::nnacl {
int BatchnormFP32Coder::Init() {
auto bn_parameter = reinterpret_cast<BatchNormParameter *>(OperatorCoder::parameter_);
std::vector<int> input_shapes = input_tensor_->shape();
@ -51,9 +50,9 @@ int BatchnormFP32Coder::DoCode(CoderContext *const context) {
MS_LOG(ERROR) << "BatchnormFP32Coder Init error";
return RET_ERROR;
}
MS_CHECK_TRUE(input_tensors_.size() == 3, "inputs size is not equal to three");
MS_CHECK_TRUE(input_tensors_.size() == DIMENSION_3D, "inputs size is not equal to three");
Tensor *mean_tensor = input_tensors_.at(1);
Tensor *var_tensor = input_tensors_.at(2);
Tensor *var_tensor = input_tensors_.at(kInputSize1);
Collect(context,
{
"nnacl/fp32/batchnorm.h",

1
mindspore/lite/micro/coder/opcoders/nnacl/fp32/biasadd_fp32_coder.cc
View File

@ -22,7 +22,6 @@
using mindspore::schema::PrimitiveType_BiasAdd;
namespace mindspore::lite::micro::nnacl {
int BiasAddFP32Coder::Prepare(CoderContext *context) {
arithmetic_parameter_ = reinterpret_cast<ArithmeticParameter *>(parameter_);
size_t data_size = input_tensors_.at(0)->ElementsNum();

1
mindspore/lite/micro/coder/opcoders/nnacl/fp32/concat_fp32_coder.cc
View File

@ -22,7 +22,6 @@
using mindspore::schema::PrimitiveType_Concat;
namespace mindspore::lite::micro::nnacl {
int ConcatFP32Coder::Prepare(CoderContext *const context) {
concat_param_ = reinterpret_cast<ConcatParameter *>(parameter_);
return ReSize();

1
mindspore/lite/micro/coder/opcoders/nnacl/fp32/conv2d_delegate_fp32_coder.cc
View File

@ -23,7 +23,6 @@
#include "coder/opcoders/nnacl/fp32/convolution_winograd_fp32_coder.h"
using mindspore::schema::PrimitiveType_Conv2DFusion;
namespace mindspore::lite::micro::nnacl {
int ConvDelegateCoder::Prepare(CoderContext *const context) {
// Update shape info of input and output
SetInputOutputShapeInfo(reinterpret_cast<ConvParameter *>(parameter_), input_tensor_, output_tensor_);

2
mindspore/lite/micro/coder/opcoders/nnacl/fp32/convolution_depthwise_fp32_coder.cc
View File

@ -30,7 +30,6 @@ int ConvolutionDepthwiseFP32Coder::Prepare(CoderContext *const context) {
}
int ConvolutionDepthwiseFP32Coder::InitWeightBias() {
// init weight: o, h, w, i; o == group, i == 1
auto *origin_weight = reinterpret_cast<float *>(filter_tensor_->data_c());
int channel = filter_tensor_->Batch();
size_t pack_weight_size = filter_tensor_->Batch() * filter_tensor_->Height() * filter_tensor_->Width();
@ -70,7 +69,6 @@ int ConvolutionDepthwiseFP32Coder::DoCode(CoderContext *const context) {
{
"ConvDwFp32Row.S",
});
nnacl::NNaclFp32Serializer code;
// call the op function
code.CodeStruct("conv_parameter", *conv_param_);

8
mindspore/lite/micro/coder/opcoders/nnacl/fp32/convolution_winograd_fp32_coder.cc
View File

@ -143,7 +143,7 @@ int ConvolutionWinogradFP32Coder::InitWeightBias() {
float matrix_b[64];
float matrix_bt[64];
float coef = 1.0f;
if (input_unit_ == 8) {
if (input_unit_ == DIMENSION_8D) {
coef = 0.5f;
}
CookToomFilter(matrix_a, matrix_at, matrix_b, matrix_bt, matrix_g, matrix_gt, coef, output_unit_, kernel_unit_);
@ -183,7 +183,7 @@ std::string ConvolutionWinogradFP32Coder::GetInputTransFunc(int input_unit) {
std::string ConvolutionWinogradFP32Coder::GetOutputTransFunc(int input_unit, int output_unit, ActType act_type) {
std::string res;
if (input_unit == 4 && output_unit < 4) {
if (input_unit == DIMENSION_4D && output_unit < DIMENSION_4D) {
if (act_type == ActType_Relu) {
return OutputTransFuncReluList4.at(output_unit);
} else if (act_type == ActType_Relu6) {
@ -191,7 +191,7 @@ std::string ConvolutionWinogradFP32Coder::GetOutputTransFunc(int input_unit, int
} else {
return OutputTransFuncList4.at(output_unit);
}
} else if (input_unit == 6 && output_unit < 6) {
} else if (input_unit == DIMENSION_6D && output_unit < DIMENSION_6D) {
if (act_type == ActType_Relu) {
return OutputTransFuncReluList6.at(output_unit);
} else if (act_type == ActType_Relu6) {
@ -199,7 +199,7 @@ std::string ConvolutionWinogradFP32Coder::GetOutputTransFunc(int input_unit, int
} else {
return OutputTransFuncList6.at(output_unit);
}
} else if (input_unit == 8 && output_unit < 8) {
} else if (input_unit == DIMENSION_8D && output_unit < DIMENSION_8D) {
if (act_type == ActType_Relu) {
return OutputTransFuncReluList8.at(output_unit);
} else if (act_type == ActType_Relu6) {

1
mindspore/lite/micro/coder/opcoders/nnacl/fp32/gather_fp32_coder.cc
View File

@ -25,7 +25,6 @@
using mindspore::schema::PrimitiveType_Gather;
namespace mindspore::lite::micro::nnacl {
int GatherFP32Coder::Prepare(CoderContext *const context) { return RET_OK; }
int GatherFP32Coder::DoCode(CoderContext *context) {

2
mindspore/lite/micro/coder/opcoders/nnacl/fp32/matmul_fp32_base_coder.cc
View File

@ -43,7 +43,7 @@ int MatMulFP32BaseCoder::ReSize() {
}
int MatMulFP32BaseCoder::InitBiasData() {
if (input_tensors_.size() == 3) {
if (input_tensors_.size() == DIMENSION_3D) {
int max_bias_data = params_->col_align_;
bias_pack_ptr_size_ = static_cast<size_t>(max_bias_data * sizeof(float));
if (bias_tensor_->ElementsNum() == 1) {

13
mindspore/lite/micro/coder/opcoders/nnacl/fp32/matmul_fp32_coder.cc
View File

@ -23,7 +23,6 @@
using mindspore::schema::PrimitiveType_MatMul;
namespace mindspore::lite::micro::nnacl {
int MatMulFP32Coder::InitShapeA() {
std::vector<int> a_shape = input_tensor_->shape();
int a_shape_size = static_cast<int>(a_shape.size());
@ -32,12 +31,12 @@ int MatMulFP32Coder::InitShapeA() {
return RET_ERROR;
}
int batch = 1;
for (int i = 0; i < a_shape_size - 2; ++i) {
for (int i = 0; i < a_shape_size - DIMENSION_2D; ++i) {
batch *= a_shape.at(i);
}
params_->batch = batch;
params_->row_ = params_->a_transpose_ ? a_shape.at(a_shape_size - 1) : a_shape.at(a_shape_size - 2);
params_->deep_ = params_->a_transpose_ ? a_shape.at(a_shape_size - 2) : a_shape.at(a_shape_size - 1);
params_->row_ = params_->a_transpose_ ? a_shape.at(a_shape_size - 1) : a_shape.at(a_shape_size - DIMENSION_2D);
params_->deep_ = params_->a_transpose_ ? a_shape.at(a_shape_size - DIMENSION_2D) : a_shape.at(a_shape_size - 1);
return RET_OK;
}
@ -49,12 +48,12 @@ int MatMulFP32Coder::InitShapeB() {
return RET_ERROR;
}
int batch = 1;
for (int i = 0; i < b_shape_size - 2; ++i) {
for (int i = 0; i < b_shape_size - DIMENSION_2D; ++i) {
batch *= b_shape.at(i);
}
params_->batch = batch;
params_->col_ = params_->b_transpose_ ? b_shape.at(b_shape_size - 2) : b_shape.at(b_shape_size - 1);
params_->deep_ = params_->b_transpose_ ? b_shape.at(b_shape_size - 1) : b_shape.at(b_shape_size - 2);
params_->col_ = params_->b_transpose_ ? b_shape.at(b_shape_size - DIMENSION_2D) : b_shape.at(b_shape_size - 1);
params_->deep_ = params_->b_transpose_ ? b_shape.at(b_shape_size - 1) : b_shape.at(b_shape_size - DIMENSION_2D);
return RET_OK;
}

2
mindspore/lite/micro/coder/opcoders/nnacl/fp32/nchw2nhwc_fp32_coder.cc
View File

@ -35,7 +35,7 @@ int Nchw2NhwcFP32Coder::DoCode(CoderContext *context) {
"nnacl/pack.c",
});
NNaclFp32Serializer code;
if (input_tensor_->shape().size() == 4) {
if (input_tensor_->shape().size() == DIMENSION_4D) {
if (input_tensor_->data_type() == kNumberTypeFloat32) {
code.CodeFunction("PackNCHWToNHWCFp32", input_tensor_, output_tensor_, output_tensor_->Batch(),
output_tensor_->Height() * output_tensor_->Width(), output_tensor_->Channel());

2
mindspore/lite/micro/coder/opcoders/nnacl/fp32/nhwc2nchw_fp32_coder.cc
View File

@ -34,7 +34,7 @@ int Nhwc2NchwFP32Coder::DoCode(CoderContext *const context) {
});
NNaclFp32Serializer code;
if (input_tensor_->shape().size() == 4) {
if (input_tensor_->shape().size() == DIMENSION_4D) {
if (input_tensor_->data_type() == kNumberTypeFloat32) {
code.CodeFunction("PackNHWCToNCHWFp32", input_tensor_, output_tensor_, output_tensor_->Batch(),
output_tensor_->Height() * output_tensor_->Width(), output_tensor_->Channel());

1
mindspore/lite/micro/coder/opcoders/nnacl/fp32/pad_fp32_coder.cc
View File

@ -25,7 +25,6 @@
using mindspore::schema::PrimitiveType_PadFusion;
namespace mindspore::lite::micro::nnacl {
int PadFP32Coder::Prepare(CoderContext *const context) {
pad_param_ = reinterpret_cast<PadParameter *>(parameter_);
return ReSize();

1
mindspore/lite/micro/coder/opcoders/nnacl/fp32/pooling_fp32_coder.cc
View File

@ -26,7 +26,6 @@ using mindspore::schema::PrimitiveType_AvgPoolFusion;
using mindspore::schema::PrimitiveType_MaxPoolFusion;
namespace mindspore::lite::micro::nnacl {
int PoolingFP32Coder::DoCode(CoderContext *const context) {
// attribute
auto pooling_parameter = reinterpret_cast<PoolingParameter *>(parameter_);

5
mindspore/lite/micro/coder/opcoders/nnacl/fp32/power_fp32_coder.cc
View File

@ -24,7 +24,6 @@
using mindspore::schema::PrimitiveType_PowFusion;
namespace mindspore::lite::micro::nnacl {
int PowerFP32Coder::DoCode(CoderContext *const context) {
scale_ = reinterpret_cast<PowerParameter *>(parameter_)->scale_;
shift_ = reinterpret_cast<PowerParameter *>(parameter_)->shift_;
@ -37,13 +36,13 @@ int PowerFP32Coder::DoCode(CoderContext *const context) {
int len = MSMIN(stride, size - stride * kDefaultTaskId);
std::string exp_addr;
bool broadcast = true;
if (input_tensors_.size() == 2) {
if (input_tensors_.size() == DIMENSION_2D) {
exp_addr = allocator_->GetRuntimeAddr(filter_tensor, true);
broadcast = !(input_tensor_->shape() == filter_tensor->shape());
}
std::string cur_exp_str;
if (broadcast) {
cur_exp_str = input_tensors_.size() == 2 ? exp_addr : "&power";
cur_exp_str = input_tensors_.size() == DIMENSION_2D ? exp_addr : "&power";
} else {
cur_exp_str = exp_addr;
}

1
mindspore/lite/micro/coder/opcoders/nnacl/fp32/reduce_fp32_coder.cc
View File

@ -21,7 +21,6 @@
#include "coder/opcoders/file_collector.h"
using mindspore::schema::PrimitiveType_ReduceFusion;
namespace mindspore::lite::micro::nnacl {
int ReduceFP32Coder::Prepare(CoderContext *const context) {
MS_CHECK_RET_CODE(ReduceBaseCoder::Init(), "init failed");

9
mindspore/lite/micro/coder/opcoders/nnacl/fp32/scale_fp32_coder.cc
View File

@ -23,7 +23,6 @@
using mindspore::schema::PrimitiveType_ScaleFusion;
namespace mindspore::lite::micro::nnacl {
int ScaleFP32Coder::InitScaleOffset() {
Tensor *scale_tensor = input_tensors_.at(kWeightIndex);
MS_CHECK_PTR(scale_tensor);
@ -40,15 +39,15 @@ int ScaleFP32Coder::InitScaleOffset() {
scale_ = nullptr;
}
if (input_tensors_.size() == 2) {
if (input_tensors_.size() == DIMENSION_2D) {
scale_param_->const_offset_ = true;
offset_ =
reinterpret_cast<float *>(allocator_->Malloc(kNumberTypeFloat32, scale_tensor->Size(), kOfflinePackWeight));
MS_CHECK_PTR(offset_);
MS_CHECK_RET_CODE(memset_s(offset_, scale_tensor->Size(), 0, scale_tensor->Size()), "memset_s failed!");
} else if (input_tensors_.size() == 3 && input_tensors_.at(2)->data_c() != nullptr) {
} else if (input_tensors_.size() == DIMENSION_3D && input_tensors_.at(kBiasIndex)->data_c() != nullptr) {
scale_param_->const_offset_ = true;
Tensor *offset_tensor = input_tensors_.at(2);
Tensor *offset_tensor = input_tensors_.at(kBiasIndex);
MS_CHECK_PTR(offset_tensor);
offset_ =
reinterpret_cast<float *>(allocator_->Malloc(kNumberTypeFloat32, offset_tensor->Size(), kOfflinePackWeight));
@ -98,7 +97,7 @@ int ScaleFP32Coder::CalculateParameter() {
int ScaleFP32Coder::Prepare(CoderContext *const context) {
this->scale_param_ = reinterpret_cast<ScaleParameter *>(parameter_);
if (input_tensors_.size() < 2 || input_tensors_.size() > 3) {
if (input_tensors_.size() < DIMENSION_2D || input_tensors_.size() > DIMENSION_3D) {
MS_LOG(ERROR) << "inputs to Scale operator should be 2 or 3, but " << input_tensors_.size() << " is given.";
return RET_ERROR;
}

2
mindspore/lite/micro/coder/opcoders/nnacl/fp32/softmax_fp32_coder.cc
View File

@ -23,7 +23,6 @@
using mindspore::schema::PrimitiveType_Softmax;
namespace mindspore::lite::micro::nnacl {
int SoftMaxFP32Coder::Prepare(CoderContext *const context) {
SoftmaxBaseCoder::Init();
// malloc tmp buffer
@ -61,7 +60,6 @@ int SoftMaxFP32Coder::DoCode(CoderContext *const context) {
code.CodeFunction("memset", sum_data_, "0", sum_data_size_);
code.CodeFunction("Softmax", input_tensor_, output_tensor_, sum_data_, "&softmax_parameter");
context->AppendCode(code.str());
return RET_OK;
}

1
mindspore/lite/micro/coder/opcoders/nnacl/fp32/tile_fp32_coder.cc
View File

@ -64,7 +64,6 @@ int TileFP32Coder::DoCode(CoderContext *const context) {
code.CodeStruct("tile_parameter", *tile_param_);
// call the op function
code.CodeFunction("Tile", input_tensor_, output_tensor_, "&tile_parameter");
context->AppendCode(code.str());
return RET_OK;
}

3
mindspore/lite/micro/coder/opcoders/nnacl/fp32/transpose_fp32_coder.cc
View File

@ -22,7 +22,6 @@
using mindspore::schema::PrimitiveType_Transpose;
namespace mindspore::lite::micro::nnacl {
int TransposeFp32Coder::Resize() {
if (input_tensors_.size() == 2) {
param_->num_axes_ = input_tensors_.at(1)->ElementsNum();
@ -31,7 +30,7 @@ int TransposeFp32Coder::Resize() {
return RET_OK;
}
// get perm data
MS_ASSERT(input_tensors_.size() == 2);
MS_ASSERT(input_tensors_.size() == DIMENSION_2D);
auto perm_tensor = input_tensors_.at(1);
int *perm_data = reinterpret_cast<int *>(perm_tensor->data_c());
MS_ASSERT(perm_data != nullptr);

1
mindspore/lite/micro/coder/opcoders/nnacl/int8/activation_int8_coder.cc
View File

@ -24,7 +24,6 @@
using mindspore::schema::PrimitiveType_Activation;
namespace mindspore::lite::micro::nnacl {
std::unique_ptr<OperatorCoder> CPUActivationINT8CoderCreator(const std::vector<Tensor *> &in_tensors,
const std::vector<Tensor *> &out_tensors,
const Model::Node *node, size_t node_index,

3
mindspore/lite/micro/coder/opcoders/nnacl/int8/add_int8_coder.cc
View File

@ -26,6 +26,7 @@
using mindspore::schema::PrimitiveType_AddFusion;
namespace mindspore::lite::micro::nnacl {
constexpr int kLeftShift = 20;
int AddInt8Coder::Prepare(CoderContext *const context) {
input0 = input_tensors().at(0);
@ -49,7 +50,7 @@ int AddInt8Coder::Init() {
const double in1_scale = input1->quant_params().front().scale;
const double out_scale = output_tensor_->quant_params().front().scale;
para_.left_shift_ = 20;
para_.left_shift_ = kLeftShift;
const double twice_max_input_scale = 2 * std::max(in0_scale, in1_scale);
const double in0_multiplier = in0_scale / twice_max_input_scale;
const double in1_multiplier = in1_scale / twice_max_input_scale;