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

!17765 fix bot engine cxx 

From: @yangjie159
Reviewed-by: @jpc_chenjianping,@wangchengyuan
Signed-off-by: @wangchengyuan
This commit is contained in:
mindspore-ci-bot 2021-06-05 05:34:42 +08:00 committed by Gitee
parent cf27d3c8dc 326f8c836f
commit a65f903fad
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; using mindspore::schema::PrimitiveType_Softmax;
namespace mindspore::lite::micro::cmsis { namespace mindspore::lite::micro::cmsis {
int SoftMaxInt8Coder::Prepare(CoderContext *const context) { int SoftMaxInt8Coder::Prepare(CoderContext *const context) {
SoftmaxBaseCoder::Init(); 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 trailing_dim = static_cast<int>(input_tensor_->shape().size()) - 1;
const int dims_count = input_tensor_->shape().size(); 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; num_rows_ = 1;
for (int i = 0; i < dims_count; ++i) { for (int i = 0; i < dims_count; ++i) {
num_rows_ *= (i == trailing_dim) ? 1 : input_tensor_->DimensionSize(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", "arm_softmax_s8.c",
}); });
code.CodeFunction("arm_softmax_s8", input_tensor_, num_rows_, row_size_, mult_, shift_, diff_min_, output_tensor_); code.CodeFunction("arm_softmax_s8", input_tensor_, num_rows_, row_size_, mult_, shift_, diff_min_, output_tensor_);
MS_LOG(INFO) << "SoftMaxInt8Coder has been called"; MS_LOG(INFO) << "SoftMaxInt8Coder has been called";
context->AppendCode(code.str()); context->AppendCode(code.str());
return RET_OK; return RET_OK;
} }
REG_OPERATOR_CODER(kARM32M, kNumberTypeInt8, PrimitiveType_Softmax, CPUOpCoderCreator<SoftMaxInt8Coder>) REG_OPERATOR_CODER(kARM32M, kNumberTypeInt8, PrimitiveType_Softmax, CPUOpCoderCreator<SoftMaxInt8Coder>)
} // namespace mindspore::lite::micro::cmsis } // 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 <vector>
#include "coder/opcoders/serializers/nnacl_serializer/nnacl_fp32_serializer.h" #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 { 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) { void Dequant::set_de_quant_buffer_str(const std::string &dequant_buffer_str) {
de_quant_buffer_str_ = "(float *)(" + 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; using mindspore::schema::PrimitiveType_Activation;
namespace mindspore::lite::micro::nnacl { namespace mindspore::lite::micro::nnacl {
int ActivationFP32Coder::DoCode(CoderContext *const context) { int ActivationFP32Coder::DoCode(CoderContext *const context) {
// attribute // attribute
auto *activation_parameter = reinterpret_cast<ActivationParameter *>(parameter_); 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"); MS_CHECK_TRUE(thread_num_ > 0, "thread_num_ <= 0");
int stride = UP_DIV(length, thread_num_); int stride = UP_DIV(length, thread_num_);
int count = MSMIN(stride, length - stride * kDefaultTaskId); int count = MSMIN(stride, length - stride * kDefaultTaskId);
Collect(context, Collect(context,
{ {
"nnacl/fp32/activation_fp32.h", "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; using mindspore::schema::PrimitiveType_AddN;
namespace mindspore::lite::micro::nnacl { namespace mindspore::lite::micro::nnacl {
int AddNFP32Coder::DoCode(CoderContext *const context) { int AddNFP32Coder::DoCode(CoderContext *const context) {
Tensor *input0 = input_tensors_.at(kInputIndex); Tensor *input0 = input_tensors_.at(kInputIndex);
Tensor *input1 = input_tensors_.at(1); 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>) REG_OPERATOR_CODER(kAllTargets, kNumberTypeFloat32, PrimitiveType_AddN, CPUOpCoderCreator<AddNFP32Coder>)
} // namespace mindspore::lite::micro::nnacl } // 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" #include "coder/log.h"
namespace mindspore::lite::micro::nnacl { namespace mindspore::lite::micro::nnacl {
namespace { namespace {
std::string wrap_void(const std::string &a) { return "(void *)(" + a + ")"; } std::string wrap_void(const std::string &a) { return "(void *)(" + a + ")"; }
std::string wrap_uint8(const std::string &a) { return "(uint8_t *)(" + 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; int out_offset = out_stride * start_batch;
arithmetic_wrapper_info_ = {offset0, stride0, offset1, stride1, out_offset, out_stride, arithmetic_func_type_}; 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_wrapper_info", arithmetic_wrapper_info_);
code->CodeStruct("arithmetic_parameter", *arithmetic_parameter_); code->CodeStruct("arithmetic_parameter", *arithmetic_parameter_);
code->CodeFunction("BatchScalarCalc", wrap_uint8(input0_ptr_str_), wrap_uint8(input1_ptr_str_), 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" #include "coder/opcoders/parallel.h"
namespace mindspore::lite::micro::nnacl { namespace mindspore::lite::micro::nnacl {
int ArithmeticSelfFP32Coder::ReSize() { int ArithmeticSelfFP32Coder::ReSize() {
data_size_ = input_tensor_->ElementsNum(); data_size_ = input_tensor_->ElementsNum();
thread_sz_count_ = MSMIN(thread_num_, static_cast<int>(data_size_)); 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_Neg, CPUOpCoderCreator<ArithmeticSelfFP32Coder>)
REG_OPERATOR_CODER(kAllTargets, kNumberTypeFloat32, PrimitiveType_Erf, CPUOpCoderCreator<ArithmeticSelfFP32Coder>) REG_OPERATOR_CODER(kAllTargets, kNumberTypeFloat32, PrimitiveType_Erf, CPUOpCoderCreator<ArithmeticSelfFP32Coder>)
} // namespace mindspore::lite::micro::nnacl } // 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" #include "coder/opcoders/serializers/nnacl_serializer/nnacl_fp32_serializer.h"
namespace mindspore::lite::micro::nnacl { namespace mindspore::lite::micro::nnacl {
using mindspore::schema::PrimitiveType_AssignAdd; using mindspore::schema::PrimitiveType_AssignAdd;
int AssignAddFP32Coder::Prepare(CoderContext *const context) { return RET_OK; } 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, kNumberTypeFloat32, PrimitiveType_AssignAdd, CPUOpCoderCreator<AssignAddFP32Coder>)
REG_OPERATOR_CODER(kAllTargets, kNumberTypeInt32, PrimitiveType_AssignAdd, CPUOpCoderCreator<AssignAddFP32Coder>) REG_OPERATOR_CODER(kAllTargets, kNumberTypeInt32, PrimitiveType_AssignAdd, CPUOpCoderCreator<AssignAddFP32Coder>)
} // namespace mindspore::lite::micro::nnacl } // 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; using mindspore::schema::PrimitiveType_BatchNorm;
namespace mindspore::lite::micro::nnacl { namespace mindspore::lite::micro::nnacl {
int BatchnormFP32Coder::Init() { int BatchnormFP32Coder::Init() {
auto bn_parameter = reinterpret_cast<BatchNormParameter *>(OperatorCoder::parameter_); auto bn_parameter = reinterpret_cast<BatchNormParameter *>(OperatorCoder::parameter_);
std::vector<int> input_shapes = input_tensor_->shape(); std::vector<int> input_shapes = input_tensor_->shape();
@ -51,9 +50,9 @@ int BatchnormFP32Coder::DoCode(CoderContext *const context) {
MS_LOG(ERROR) << "BatchnormFP32Coder Init error"; MS_LOG(ERROR) << "BatchnormFP32Coder Init error";
return RET_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 *mean_tensor = input_tensors_.at(1);
Tensor *var_tensor = input_tensors_.at(2); Tensor *var_tensor = input_tensors_.at(kInputSize1);
Collect(context, Collect(context,
{ {
"nnacl/fp32/batchnorm.h", "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; using mindspore::schema::PrimitiveType_BiasAdd;
namespace mindspore::lite::micro::nnacl { namespace mindspore::lite::micro::nnacl {
int BiasAddFP32Coder::Prepare(CoderContext *context) { int BiasAddFP32Coder::Prepare(CoderContext *context) {
arithmetic_parameter_ = reinterpret_cast<ArithmeticParameter *>(parameter_); arithmetic_parameter_ = reinterpret_cast<ArithmeticParameter *>(parameter_);
size_t data_size = input_tensors_.at(0)->ElementsNum(); 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; using mindspore::schema::PrimitiveType_Concat;
namespace mindspore::lite::micro::nnacl { namespace mindspore::lite::micro::nnacl {
int ConcatFP32Coder::Prepare(CoderContext *const context) { int ConcatFP32Coder::Prepare(CoderContext *const context) {
concat_param_ = reinterpret_cast<ConcatParameter *>(parameter_); concat_param_ = reinterpret_cast<ConcatParameter *>(parameter_);
return ReSize(); 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" #include "coder/opcoders/nnacl/fp32/convolution_winograd_fp32_coder.h"
using mindspore::schema::PrimitiveType_Conv2DFusion; using mindspore::schema::PrimitiveType_Conv2DFusion;
namespace mindspore::lite::micro::nnacl { namespace mindspore::lite::micro::nnacl {
int ConvDelegateCoder::Prepare(CoderContext *const context) { int ConvDelegateCoder::Prepare(CoderContext *const context) {
// Update shape info of input and output // Update shape info of input and output
SetInputOutputShapeInfo(reinterpret_cast<ConvParameter *>(parameter_), input_tensor_, output_tensor_); 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() { int ConvolutionDepthwiseFP32Coder::InitWeightBias() {
// init weight: o, h, w, i; o == group, i == 1
auto *origin_weight = reinterpret_cast<float *>(filter_tensor_->data_c()); auto *origin_weight = reinterpret_cast<float *>(filter_tensor_->data_c());
int channel = filter_tensor_->Batch(); int channel = filter_tensor_->Batch();
size_t pack_weight_size = filter_tensor_->Batch() * filter_tensor_->Height() * filter_tensor_->Width(); 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", "ConvDwFp32Row.S",
}); });
nnacl::NNaclFp32Serializer code; nnacl::NNaclFp32Serializer code;
// call the op function // call the op function
code.CodeStruct("conv_parameter", *conv_param_); 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_b[64];
float matrix_bt[64]; float matrix_bt[64];
float coef = 1.0f; float coef = 1.0f;
if (input_unit_ == 8) { if (input_unit_ == DIMENSION_8D) {
coef = 0.5f; coef = 0.5f;
} }
CookToomFilter(matrix_a, matrix_at, matrix_b, matrix_bt, matrix_g, matrix_gt, coef, output_unit_, kernel_unit_); 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 ConvolutionWinogradFP32Coder::GetOutputTransFunc(int input_unit, int output_unit, ActType act_type) {
std::string res; std::string res;
if (input_unit == 4 && output_unit < 4) { if (input_unit == DIMENSION_4D && output_unit < DIMENSION_4D) {
if (act_type == ActType_Relu) { if (act_type == ActType_Relu) {
return OutputTransFuncReluList4.at(output_unit); return OutputTransFuncReluList4.at(output_unit);
} else if (act_type == ActType_Relu6) { } else if (act_type == ActType_Relu6) {
@ -191,7 +191,7 @@ std::string ConvolutionWinogradFP32Coder::GetOutputTransFunc(int input_unit, int
} else { } else {
return OutputTransFuncList4.at(output_unit); 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) { if (act_type == ActType_Relu) {
return OutputTransFuncReluList6.at(output_unit); return OutputTransFuncReluList6.at(output_unit);
} else if (act_type == ActType_Relu6) { } else if (act_type == ActType_Relu6) {
@ -199,7 +199,7 @@ std::string ConvolutionWinogradFP32Coder::GetOutputTransFunc(int input_unit, int
} else { } else {
return OutputTransFuncList6.at(output_unit); 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) { if (act_type == ActType_Relu) {
return OutputTransFuncReluList8.at(output_unit); return OutputTransFuncReluList8.at(output_unit);
} else if (act_type == ActType_Relu6) { } 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; using mindspore::schema::PrimitiveType_Gather;
namespace mindspore::lite::micro::nnacl { namespace mindspore::lite::micro::nnacl {
int GatherFP32Coder::Prepare(CoderContext *const context) { return RET_OK; } int GatherFP32Coder::Prepare(CoderContext *const context) { return RET_OK; }
int GatherFP32Coder::DoCode(CoderContext *context) { 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() { int MatMulFP32BaseCoder::InitBiasData() {
if (input_tensors_.size() == 3) { if (input_tensors_.size() == DIMENSION_3D) {
int max_bias_data = params_->col_align_; int max_bias_data = params_->col_align_;
bias_pack_ptr_size_ = static_cast<size_t>(max_bias_data * sizeof(float)); bias_pack_ptr_size_ = static_cast<size_t>(max_bias_data * sizeof(float));
if (bias_tensor_->ElementsNum() == 1) { 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; using mindspore::schema::PrimitiveType_MatMul;
namespace mindspore::lite::micro::nnacl { namespace mindspore::lite::micro::nnacl {
int MatMulFP32Coder::InitShapeA() { int MatMulFP32Coder::InitShapeA() {
std::vector<int> a_shape = input_tensor_->shape(); std::vector<int> a_shape = input_tensor_->shape();
int a_shape_size = static_cast<int>(a_shape.size()); int a_shape_size = static_cast<int>(a_shape.size());
@ -32,12 +31,12 @@ int MatMulFP32Coder::InitShapeA() {
return RET_ERROR; return RET_ERROR;
} }
int batch = 1; 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); batch *= a_shape.at(i);
} }
params_->batch = batch; params_->batch = batch;
params_->row_ = params_->a_transpose_ ? a_shape.at(a_shape_size - 1) : a_shape.at(a_shape_size - 2); 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 - 2) : a_shape.at(a_shape_size - 1); params_->deep_ = params_->a_transpose_ ? a_shape.at(a_shape_size - DIMENSION_2D) : a_shape.at(a_shape_size - 1);
return RET_OK; return RET_OK;
} }
@ -49,12 +48,12 @@ int MatMulFP32Coder::InitShapeB() {
return RET_ERROR; return RET_ERROR;
} }
int batch = 1; 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); batch *= b_shape.at(i);
} }
params_->batch = batch; params_->batch = batch;
params_->col_ = params_->b_transpose_ ? b_shape.at(b_shape_size - 2) : b_shape.at(b_shape_size - 1); 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 - 2); params_->deep_ = params_->b_transpose_ ? b_shape.at(b_shape_size - 1) : b_shape.at(b_shape_size - DIMENSION_2D);
return RET_OK; 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", "nnacl/pack.c",
}); });
NNaclFp32Serializer code; NNaclFp32Serializer code;
if (input_tensor_->shape().size() == 4) { if (input_tensor_->shape().size() == DIMENSION_4D) {
if (input_tensor_->data_type() == kNumberTypeFloat32) { if (input_tensor_->data_type() == kNumberTypeFloat32) {
code.CodeFunction("PackNCHWToNHWCFp32", input_tensor_, output_tensor_, output_tensor_->Batch(), code.CodeFunction("PackNCHWToNHWCFp32", input_tensor_, output_tensor_, output_tensor_->Batch(),
output_tensor_->Height() * output_tensor_->Width(), output_tensor_->Channel()); 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; NNaclFp32Serializer code;
if (input_tensor_->shape().size() == 4) { if (input_tensor_->shape().size() == DIMENSION_4D) {
if (input_tensor_->data_type() == kNumberTypeFloat32) { if (input_tensor_->data_type() == kNumberTypeFloat32) {
code.CodeFunction("PackNHWCToNCHWFp32", input_tensor_, output_tensor_, output_tensor_->Batch(), code.CodeFunction("PackNHWCToNCHWFp32", input_tensor_, output_tensor_, output_tensor_->Batch(),
output_tensor_->Height() * output_tensor_->Width(), output_tensor_->Channel()); 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; using mindspore::schema::PrimitiveType_PadFusion;
namespace mindspore::lite::micro::nnacl { namespace mindspore::lite::micro::nnacl {
int PadFP32Coder::Prepare(CoderContext *const context) { int PadFP32Coder::Prepare(CoderContext *const context) {
pad_param_ = reinterpret_cast<PadParameter *>(parameter_); pad_param_ = reinterpret_cast<PadParameter *>(parameter_);
return ReSize(); 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; using mindspore::schema::PrimitiveType_MaxPoolFusion;
namespace mindspore::lite::micro::nnacl { namespace mindspore::lite::micro::nnacl {
int PoolingFP32Coder::DoCode(CoderContext *const context) { int PoolingFP32Coder::DoCode(CoderContext *const context) {
// attribute // attribute
auto pooling_parameter = reinterpret_cast<PoolingParameter *>(parameter_); 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; using mindspore::schema::PrimitiveType_PowFusion;
namespace mindspore::lite::micro::nnacl { namespace mindspore::lite::micro::nnacl {
int PowerFP32Coder::DoCode(CoderContext *const context) { int PowerFP32Coder::DoCode(CoderContext *const context) {
scale_ = reinterpret_cast<PowerParameter *>(parameter_)->scale_; scale_ = reinterpret_cast<PowerParameter *>(parameter_)->scale_;
shift_ = reinterpret_cast<PowerParameter *>(parameter_)->shift_; shift_ = reinterpret_cast<PowerParameter *>(parameter_)->shift_;
@ -37,13 +36,13 @@ int PowerFP32Coder::DoCode(CoderContext *const context) {
int len = MSMIN(stride, size - stride * kDefaultTaskId); int len = MSMIN(stride, size - stride * kDefaultTaskId);
std::string exp_addr; std::string exp_addr;
bool broadcast = true; bool broadcast = true;
if (input_tensors_.size() == 2) { if (input_tensors_.size() == DIMENSION_2D) {
exp_addr = allocator_->GetRuntimeAddr(filter_tensor, true); exp_addr = allocator_->GetRuntimeAddr(filter_tensor, true);
broadcast = !(input_tensor_->shape() == filter_tensor->shape()); broadcast = !(input_tensor_->shape() == filter_tensor->shape());
} }
std::string cur_exp_str; std::string cur_exp_str;
if (broadcast) { if (broadcast) {
cur_exp_str = input_tensors_.size() == 2 ? exp_addr : "&power"; cur_exp_str = input_tensors_.size() == DIMENSION_2D ? exp_addr : "&power";
} else { } else {
cur_exp_str = exp_addr; 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" #include "coder/opcoders/file_collector.h"
using mindspore::schema::PrimitiveType_ReduceFusion; using mindspore::schema::PrimitiveType_ReduceFusion;
namespace mindspore::lite::micro::nnacl { namespace mindspore::lite::micro::nnacl {
int ReduceFP32Coder::Prepare(CoderContext *const context) { int ReduceFP32Coder::Prepare(CoderContext *const context) {
MS_CHECK_RET_CODE(ReduceBaseCoder::Init(), "init failed"); 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; using mindspore::schema::PrimitiveType_ScaleFusion;
namespace mindspore::lite::micro::nnacl { namespace mindspore::lite::micro::nnacl {
int ScaleFP32Coder::InitScaleOffset() { int ScaleFP32Coder::InitScaleOffset() {
Tensor *scale_tensor = input_tensors_.at(kWeightIndex); Tensor *scale_tensor = input_tensors_.at(kWeightIndex);
MS_CHECK_PTR(scale_tensor); MS_CHECK_PTR(scale_tensor);
@ -40,15 +39,15 @@ int ScaleFP32Coder::InitScaleOffset() {
scale_ = nullptr; scale_ = nullptr;
} }
if (input_tensors_.size() == 2) { if (input_tensors_.size() == DIMENSION_2D) {
scale_param_->const_offset_ = true; scale_param_->const_offset_ = true;
offset_ = offset_ =
reinterpret_cast<float *>(allocator_->Malloc(kNumberTypeFloat32, scale_tensor->Size(), kOfflinePackWeight)); reinterpret_cast<float *>(allocator_->Malloc(kNumberTypeFloat32, scale_tensor->Size(), kOfflinePackWeight));
MS_CHECK_PTR(offset_); MS_CHECK_PTR(offset_);
MS_CHECK_RET_CODE(memset_s(offset_, scale_tensor->Size(), 0, scale_tensor->Size()), "memset_s failed!"); 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; scale_param_->const_offset_ = true;
Tensor *offset_tensor = input_tensors_.at(2); Tensor *offset_tensor = input_tensors_.at(kBiasIndex);
MS_CHECK_PTR(offset_tensor); MS_CHECK_PTR(offset_tensor);
offset_ = offset_ =
reinterpret_cast<float *>(allocator_->Malloc(kNumberTypeFloat32, offset_tensor->Size(), kOfflinePackWeight)); reinterpret_cast<float *>(allocator_->Malloc(kNumberTypeFloat32, offset_tensor->Size(), kOfflinePackWeight));
@ -98,7 +97,7 @@ int ScaleFP32Coder::CalculateParameter() {
int ScaleFP32Coder::Prepare(CoderContext *const context) { int ScaleFP32Coder::Prepare(CoderContext *const context) {
this->scale_param_ = reinterpret_cast<ScaleParameter *>(parameter_); 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."; MS_LOG(ERROR) << "inputs to Scale operator should be 2 or 3, but " << input_tensors_.size() << " is given.";
return RET_ERROR; 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; using mindspore::schema::PrimitiveType_Softmax;
namespace mindspore::lite::micro::nnacl { namespace mindspore::lite::micro::nnacl {
int SoftMaxFP32Coder::Prepare(CoderContext *const context) { int SoftMaxFP32Coder::Prepare(CoderContext *const context) {
SoftmaxBaseCoder::Init(); SoftmaxBaseCoder::Init();
// malloc tmp buffer // malloc tmp buffer
@ -61,7 +60,6 @@ int SoftMaxFP32Coder::DoCode(CoderContext *const context) {
code.CodeFunction("memset", sum_data_, "0", sum_data_size_); code.CodeFunction("memset", sum_data_, "0", sum_data_size_);
code.CodeFunction("Softmax", input_tensor_, output_tensor_, sum_data_, "&softmax_parameter"); code.CodeFunction("Softmax", input_tensor_, output_tensor_, sum_data_, "&softmax_parameter");
context->AppendCode(code.str()); context->AppendCode(code.str());
return RET_OK; 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_); code.CodeStruct("tile_parameter", *tile_param_);
// call the op function // call the op function
code.CodeFunction("Tile", input_tensor_, output_tensor_, "&tile_parameter"); code.CodeFunction("Tile", input_tensor_, output_tensor_, "&tile_parameter");
context->AppendCode(code.str()); context->AppendCode(code.str());
return RET_OK; 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; using mindspore::schema::PrimitiveType_Transpose;
namespace mindspore::lite::micro::nnacl { namespace mindspore::lite::micro::nnacl {
int TransposeFp32Coder::Resize() { int TransposeFp32Coder::Resize() {
if (input_tensors_.size() == 2) { if (input_tensors_.size() == 2) {
param_->num_axes_ = input_tensors_.at(1)->ElementsNum(); param_->num_axes_ = input_tensors_.at(1)->ElementsNum();
@ -31,7 +30,7 @@ int TransposeFp32Coder::Resize() {
return RET_OK; return RET_OK;
} }
// get perm data // get perm data
MS_ASSERT(input_tensors_.size() == 2); MS_ASSERT(input_tensors_.size() == DIMENSION_2D);
auto perm_tensor = input_tensors_.at(1); auto perm_tensor = input_tensors_.at(1);
int *perm_data = reinterpret_cast<int *>(perm_tensor->data_c()); int *perm_data = reinterpret_cast<int *>(perm_tensor->data_c());
MS_ASSERT(perm_data != nullptr); 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; using mindspore::schema::PrimitiveType_Activation;
namespace mindspore::lite::micro::nnacl { namespace mindspore::lite::micro::nnacl {
std::unique_ptr<OperatorCoder> CPUActivationINT8CoderCreator(const std::vector<Tensor *> &in_tensors, std::unique_ptr<OperatorCoder> CPUActivationINT8CoderCreator(const std::vector<Tensor *> &in_tensors,
const std::vector<Tensor *> &out_tensors, const std::vector<Tensor *> &out_tensors,
const Model::Node *node, size_t node_index, 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; using mindspore::schema::PrimitiveType_AddFusion;
namespace mindspore::lite::micro::nnacl { namespace mindspore::lite::micro::nnacl {
constexpr int kLeftShift = 20;
int AddInt8Coder::Prepare(CoderContext *const context) { int AddInt8Coder::Prepare(CoderContext *const context) {
input0 = input_tensors().at(0); input0 = input_tensors().at(0);
@ -49,7 +50,7 @@ int AddInt8Coder::Init() {
const double in1_scale = input1->quant_params().front().scale; const double in1_scale = input1->quant_params().front().scale;
const double out_scale = output_tensor_->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 twice_max_input_scale = 2 * std::max(in0_scale, in1_scale);
const double in0_multiplier = in0_scale / twice_max_input_scale; const double in0_multiplier = in0_scale / twice_max_input_scale;
const double in1_multiplier = in1_scale / twice_max_input_scale; const double in1_multiplier = in1_scale / twice_max_input_scale;