move cplusplus file to C file

mindspore/lite/src/runtime/kernel/arm/CMakeLists.txt

@@ -2,10 +2,10 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR}/)
 
 file(GLOB KERNEL_SRC
         ${CMAKE_CURRENT_SOURCE_DIR}/base/*.cc
-        nnacl/*.cc
-        nnacl/fp32/*.cc
-        nnacl/int8/*.cc
-        nnacl/quantization/*.cc
+        nnacl/*.c
+        nnacl/fp32/*.c
+        nnacl/int8/*.c
+        nnacl/quantization/*.c
         ${CMAKE_CURRENT_SOURCE_DIR}/fp32/*.cc
         ${CMAKE_CURRENT_SOURCE_DIR}/int8/*.cc
         )
@@ -13,13 +13,15 @@ file(GLOB KERNEL_SRC
 if (SUPPORT_TRAIN)
 file (GLOB TRAIN_KERNEL_SRC
         ${CMAKE_CURRENT_SOURCE_DIR}/fp32_grad/*.cc
-        ${CMAKE_CURRENT_SOURCE_DIR}/nnacl/fp32_grad/*.cc
+        ${CMAKE_CURRENT_SOURCE_DIR}/nnacl/fp32_grad/*.c
         )
 endif()
 
 if (PLATFORM_ARM64)
     # assembly
     file(GLOB ASSEMBLY_SRC nnacl/assembly/arm64/*.s
+            nnacl/assembly/opt/*.s
+            nnacl/assembly/opt/*.S
             nnacl/assembly/arm64/*.S)
     set_property(SOURCE ${ASSEMBLY_SRC} PROPERTY LANGUAGE C)
     set(KERNEL_SRC ${KERNEL_SRC} ${ASSEMBLY_SRC})
@@ -29,6 +31,8 @@ if (PLATFORM_ARM32)
     # assembly
     file(GLOB ASSEMBLY_SRC nnacl/assembly/arm32/*.s
             nnacl/assembly/arm32/*.S
+            nnacl/assembly/opt/*.s
+            nnacl/assembly/opt/*.S
             )
     set_property(SOURCE ${ASSEMBLY_SRC} PROPERTY LANGUAGE C)
     set(KERNEL_SRC ${KERNEL_SRC} ${ASSEMBLY_SRC})

mindspore/lite/src/runtime/kernel/arm/base/quant_dtype_cast.cc

@@ -54,7 +54,8 @@ int QuantDTypeCastCPUKernel::Init() {
     }
     inverse_ = true;
   } else {
-    MS_LOG(ERROR) << "param data type not supported:" << " src: " << param->srcT << " dst: " << param->dstT;
+    MS_LOG(ERROR) << "param data type not supported:"
+                  << " src: " << param->srcT << " dst: " << param->dstT;
     return RET_PARAM_INVALID;
   }
 
@@ -81,11 +82,11 @@ int QuantDTypeCastCPUKernel::QuantDTypeCast(int task_id) {
   auto quant_arg = in_tensors_.front()->GetQuantParams().front();
   int ret;
   if (inverse_) {
-    ret = DequantizeInt8(int8_ptr_ + thread_offset, float32_ptr_ + thread_offset, quant_arg.scale, quant_arg.zeroPoint,
-                         num_unit_thread);
+    ret = DoDequantizeInt8(int8_ptr_ + thread_offset, float32_ptr_ + thread_offset, quant_arg.scale,
+                           quant_arg.zeroPoint, num_unit_thread);
   } else {
-    ret = QuantizeToInt8(float32_ptr_ + thread_offset, int8_ptr_ + thread_offset, quant_arg.scale, quant_arg.zeroPoint,
-                         num_unit_thread);
+    ret = DoQuantizeToInt8(float32_ptr_ + thread_offset, int8_ptr_ + thread_offset, quant_arg.scale,
+                           quant_arg.zeroPoint, num_unit_thread);
   }
   if (ret != RET_OK) {
     MS_LOG(ERROR) << "QuantDTypeCast error task_id[" << task_id << "] error_code[" << ret << "]";

mindspore/lite/src/runtime/kernel/arm/base/resize_base.h

@@ -27,9 +27,9 @@ namespace mindspore::kernel {
 class ResizeBaseCPUKernel : public LiteKernel {
  public:
   ResizeBaseCPUKernel(OpParameter *parameter, const std::vector<lite::tensor::Tensor *> &inputs,
-                  const std::vector<lite::tensor::Tensor *> &outputs, const lite::Context *ctx,
-                  const lite::Primitive *primitive)
-    : LiteKernel(parameter, inputs, outputs, ctx, primitive), context_(ctx) {}
+                      const std::vector<lite::tensor::Tensor *> &outputs, const lite::Context *ctx,
+                      const lite::Primitive *primitive)
+      : LiteKernel(parameter, inputs, outputs, ctx, primitive), context_(ctx) {}
 
   ~ResizeBaseCPUKernel() = default;
 

mindspore/lite/src/runtime/kernel/arm/fp16/convolution_depthwise_fp16.h

@@ -22,6 +22,17 @@
 #include "src/runtime/kernel/arm/base/convolution_base.h"
 #include "src/runtime/kernel/arm/nnacl/fp16/conv_depthwise_fp16.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+void ConvDwC8Fp16(float16_t *output_data, const float16_t *input_data, const float16_t *weight_data,
+                  const float16_t *bias_data, const ConvParameter *conv_param, const SlidingWindowParam *sliding,
+                  int task_id);
+#ifdef __cplusplus
+}
+#endif
+
+
 namespace mindspore::kernel {
 class ConvolutionDepthwiseFp16CPUKernel : public ConvolutionBaseCPUKernel {
  public:

mindspore/lite/src/runtime/kernel/arm/fp16/deconvolution_depthwise_fp16.h

@@ -22,6 +22,17 @@
 #include "src/runtime/kernel/arm/base/convolution_base.h"
 #include "src/runtime/kernel/arm/nnacl/fp16/conv_depthwise_fp16.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+void DeconvDwC8Fp16(float16_t *output_data, const float16_t *input_data, const float16_t *weight_data,
+                    const float16_t *bias_data, const ConvParameter *conv_param, const SlidingWindowParam *sliding,
+                    int task_id);
+void ComputeStrides(int *shape, int *strides, int ndim);
+#ifdef __cplusplus
+}
+#endif
+
 namespace mindspore::kernel {
 class DeconvolutionDepthwiseFp16CPUKernel : public ConvolutionBaseCPUKernel {
  public:

mindspore/lite/src/runtime/kernel/arm/fp32/arithmetic.cc

@@ -40,9 +40,7 @@ void ArithmeticCPUKernel::FreeTileData() {
   }
 }
 
-ArithmeticCPUKernel::~ArithmeticCPUKernel() {
-  FreeTileData();
-}
+ArithmeticCPUKernel::~ArithmeticCPUKernel() { FreeTileData(); }
 
 int ArithmeticCPUKernel::Init() {
   if (!InferShapeDone()) {

mindspore/lite/src/runtime/kernel/arm/fp32/caffeprelu.cc

@@ -31,7 +31,7 @@ namespace mindspore::kernel {
 int CaffePReluCPUKernel::Init() { return RET_OK; }
 
 int CaffePReluCPUKernel::DoExcute(int task_id) {
-  PRelu(input_data, output_data, prelu_param_, task_id);
+  CaffePRelu(input_data, output_data, prelu_param_, task_id);
   return RET_OK;
 }
 

mindspore/lite/src/runtime/kernel/arm/fp32/cast.cc

@@ -79,17 +79,17 @@ int CastCPUKernel::DoCast(int thread_id) {
     }
   } else {
     switch (input_data_type) {
-    case kNumberTypeUInt8:
-      Uint8ToFloat32(reinterpret_cast<uint8_t *>(input->Data()) + offset,
-                     reinterpret_cast<float *>(output_data) + offset, data_num);
-      break;
-    case kNumberTypeInt32:
-      Int32ToFloat32(reinterpret_cast<int32_t *>(input->Data()) + offset,
-                     reinterpret_cast<float *>(output_data) + offset, data_num);
-      break;
-    default:
-      MS_LOG(ERROR) << "Unsupport input data type " << input_data_type;
-      return RET_ERROR;
+      case kNumberTypeUInt8:
+        Uint8ToFloat32(reinterpret_cast<uint8_t *>(input->Data()) + offset,
+                       reinterpret_cast<float *>(output_data) + offset, data_num);
+        break;
+      case kNumberTypeInt32:
+        Int32ToFloat32(reinterpret_cast<int32_t *>(input->Data()) + offset,
+                       reinterpret_cast<float *>(output_data) + offset, data_num);
+        break;
+      default:
+        MS_LOG(ERROR) << "Unsupport input data type " << input_data_type;
+        return RET_ERROR;
     }
   }
   return RET_OK;

mindspore/lite/src/runtime/kernel/arm/fp32/resize.cc

@@ -66,8 +66,8 @@ int ResizeCPUKernel::RunImpl(int task_id) {
   int ret = 0;
   switch (method_) {
     case static_cast<int>(schema::ResizeMethod_BILINEAR): {
-      ret = ResizeBilinear(input_data, output_data, input_shape.data(), out_tensors_[0]->shape().data(),
-                             align_corners_, task_id, context_->thread_num_);
+      ret = ResizeBilinear(input_data, output_data, input_shape.data(), out_tensors_[0]->shape().data(), align_corners_,
+                           task_id, context_->thread_num_);
       break;
     }
     case static_cast<int>(schema::ResizeMethod_NEAREST_NEIGHBOR): {
@@ -76,7 +76,7 @@ int ResizeCPUKernel::RunImpl(int task_id) {
         return RET_ERROR;
       }
       ret = ResizeNearestNeighbor(input_data, output_data, input_shape.data(), out_tensors_[0]->shape().data(), task_id,
-                                    context_->thread_num_);
+                                  context_->thread_num_);
       break;
     }
     case schema::ResizeMethod_UNKNOW:

mindspore/lite/src/runtime/kernel/arm/fp32/scale.h

@@ -26,8 +26,8 @@ namespace mindspore::kernel {
 class ScaleCPUKernel : public LiteKernel {
  public:
   ScaleCPUKernel(OpParameter *parameter, const std::vector<lite::tensor::Tensor *> &inputs,
-                          const std::vector<lite::tensor::Tensor *> &outputs, const lite::Context *ctx,
-                          const lite::Primitive *primitive)
+                 const std::vector<lite::tensor::Tensor *> &outputs, const lite::Context *ctx,
+                 const lite::Primitive *primitive)
       : LiteKernel(parameter, inputs, outputs, ctx, primitive) {
     scale_param_ = reinterpret_cast<ScaleParameter *>(op_parameter_);
   }

mindspore/lite/src/runtime/kernel/arm/fp32/scatter_nd.cc

@@ -44,7 +44,7 @@ int ScatterNDCPUKernel::Init() {
 }
 
 int ScatterNDCPUKernel::ReSize() {
-auto shape = in_tensors_.at(kScatterShapeIndex);
+  auto shape = in_tensors_.at(kScatterShapeIndex);
   auto indices = in_tensors_.at(kScatterIndicesIndex);
   auto update = in_tensors_.at(kScatterUpdateIndex);
 

mindspore/lite/src/runtime/kernel/arm/fp32/space_to_batch.cc

@@ -23,9 +23,9 @@
 #include "include/errorcode.h"
 
 using mindspore::lite::KernelRegistrar;
+using mindspore::lite::RET_ERROR;
 using mindspore::lite::RET_FORMAT_ERR;
 using mindspore::lite::RET_OK;
-using mindspore::lite::RET_ERROR;
 using mindspore::lite::RET_OP_EXECUTE_FAILURE;
 using mindspore::schema::PrimitiveType_SpaceToBatch;
 
@@ -73,8 +73,8 @@ int SpaceToBatchCPUKernel::Run() {
   float *tmp_space[3] = {nullptr, nullptr, nullptr};
   if (param->need_paddings_) {
     for (int i = 0; i < 3; ++i) {
-      tmp_space[i]
-        = reinterpret_cast<float *>(context_->allocator->Malloc(param->num_elements_padded_ * sizeof(float)));
+      tmp_space[i] =
+        reinterpret_cast<float *>(context_->allocator->Malloc(param->num_elements_padded_ * sizeof(float)));
       (void)memset(tmp_space[i], 0, param->num_elements_padded_ * sizeof(float));
       if (tmp_space[i] == nullptr) {
         MS_LOG(ERROR) << "malloc tmp buffer fail!";

mindspore/lite/src/runtime/kernel/arm/fp32/space_to_depth.cc

@@ -45,7 +45,7 @@ int SpaceToDepthCPUKernel::Init() {
 }
 
 int SpaceToDepthCPUKernel::ReSize() {
-if (in_tensors_[0]->GetFormat() != schema::Format_NHWC) {
+  if (in_tensors_[0]->GetFormat() != schema::Format_NHWC) {
     MS_LOG(ERROR) << "space_to_depth only support NHWC now!";
     return RET_FORMAT_ERR;
   }

mindspore/lite/src/runtime/kernel/arm/int8/argminmax_int8.cc

@@ -62,22 +62,22 @@ int ArgMinMaxInt8CPUKernel::Run() {
   auto in_shape = input->shape().data();
   auto param = reinterpret_cast<ArgMinMaxParameter *>(op_parameter_);
   if (param->topk_ == 1) {
-    ArgMinMaxQuant(input_data, output_data, in_shape, param, &in_quant_arg_, &out_quant_arg_);
+    Int8ArgMinMaxQuant(input_data, output_data, in_shape, param, &in_quant_arg_, &out_quant_arg_);
     return RET_OK;
   }
 
   switch (param->axis_) {
     case 0:
-      ArgMinMaxDim0(input_data, output_data, in_shape, param, &in_quant_arg_, &out_quant_arg_);
+      Int8ArgMinMaxDim0(input_data, output_data, in_shape, param, &in_quant_arg_, &out_quant_arg_);
       break;
     case 1:
-      ArgMinMaxDim1(input_data, output_data, in_shape, param, &in_quant_arg_, &out_quant_arg_);
+      Int8ArgMinMaxDim1(input_data, output_data, in_shape, param, &in_quant_arg_, &out_quant_arg_);
       break;
     case 2:
-      ArgMinMaxDim2(input_data, output_data, in_shape, param, &in_quant_arg_, &out_quant_arg_);
+      Int8ArgMinMaxDim2(input_data, output_data, in_shape, param, &in_quant_arg_, &out_quant_arg_);
       break;
     case 3:
-      ArgMinMaxDim3(input_data, output_data, in_shape, param, &in_quant_arg_, &out_quant_arg_);
+      Int8ArgMinMaxDim3(input_data, output_data, in_shape, param, &in_quant_arg_, &out_quant_arg_);
       break;
   }
   FreeTmpMemory();

mindspore/lite/src/runtime/kernel/arm/int8/arithmetic_int8.cc

@@ -71,9 +71,7 @@ void ArithmeticInt8CPUKernel::FreeTileData() {
   tile_data1_ = nullptr;
 }
 
-ArithmeticInt8CPUKernel::~ArithmeticInt8CPUKernel() {
-  FreeTileData();
-}
+ArithmeticInt8CPUKernel::~ArithmeticInt8CPUKernel() { FreeTileData(); }
 
 int ArithmeticInt8CPUKernel::Init() {
   switch (op_parameter_->type_) {

mindspore/lite/src/runtime/kernel/arm/int8/arithmetic_self_int8.h

@@ -48,37 +48,37 @@ class ArithmeticSelfInt8CPUKernel : public LiteKernel {
       : LiteKernel(parameter, inputs, outputs, ctx, primitive), ctx_(ctx), thread_count_(ctx->thread_num_) {
     switch (parameter->type_) {
       case PrimitiveType_Round:
-        arithmeticSelf_run_ = ElementRound;
+        arithmeticSelf_run_ = Int8ElementRound;
         break;
       case PrimitiveType_Floor:
-        arithmeticSelf_run_ = ElementFloor;
+        arithmeticSelf_run_ = Int8ElementFloor;
         break;
       case PrimitiveType_Ceil:
-        arithmeticSelf_run_ = ElementCeil;
+        arithmeticSelf_run_ = Int8ElementCeil;
         break;
       case PrimitiveType_Abs:
-        arithmeticSelf_run_ = ElementAbs;
+        arithmeticSelf_run_ = Int8ElementAbs;
         break;
       case PrimitiveType_Sin:
-        arithmeticSelf_run_ = ElementSin;
+        arithmeticSelf_run_ = Int8ElementSin;
         break;
       case PrimitiveType_Cos:
-        arithmeticSelf_run_ = ElementCos;
+        arithmeticSelf_run_ = Int8ElementCos;
         break;
       case PrimitiveType_Log:
-        arithmeticSelf_run_ = ElementLog;
+        arithmeticSelf_run_ = Int8ElementLog;
         break;
       case PrimitiveType_Sqrt:
-        arithmeticSelf_run_ = ElementSqrt;
+        arithmeticSelf_run_ = Int8ElementSqrt;
         break;
       case PrimitiveType_Rsqrt:
-        arithmeticSelf_run_ = ElementRsqrt;
+        arithmeticSelf_run_ = Int8ElementRsqrt;
         break;
       case PrimitiveType_Square:
-        arithmeticSelf_run_ = ElementSquare;
+        arithmeticSelf_run_ = Int8ElementSquare;
         break;
       case PrimitiveType_LogicalNot:
-        arithmeticSelf_run_ = ElementLogicalNot;
+        arithmeticSelf_run_ = Int8ElementLogicalNot;
         break;
       default:
         break;

mindspore/lite/src/runtime/kernel/arm/int8/batch_to_space_int8.cc

@@ -70,11 +70,11 @@ int BatchToSpaceInt8CPUKernel::Run() {
     }
   } else {
     if (IsNoCrop()) {
-      BatchToSpaceNoCropForNHWC(input_data, output_data, in_shape.data(), out_shape[0], param->block_shape_,
-                                &in_quant_arg_, &out_quant_arg_);
+      BatchToSpaceNoCropForNHWCInt8(input_data, output_data, in_shape.data(), out_shape[0], param->block_shape_,
+                                    &in_quant_arg_, &out_quant_arg_);
     } else {
-      BatchToSpaceForNHWC(input_data, output_data, in_shape.data(), out_shape[0], param->block_shape_, param->crops_,
-                          &in_quant_arg_, &out_quant_arg_);
+      BatchToSpaceForNHWCInt8(input_data, output_data, in_shape.data(), out_shape[0], param->block_shape_,
+                              param->crops_, &in_quant_arg_, &out_quant_arg_);
     }
   }
 

mindspore/lite/src/runtime/kernel/arm/int8/concat_int8.cc

@@ -55,7 +55,6 @@ int ConcatInt8CPUKernel::Init() {
   return ReSize();
 }
 
-
 int ConcatInt8CPUKernel::ReSize() {
   auto ret = ConcatBaseCPUKernel::ReSize();
   if (ret != RET_OK) {
@@ -127,7 +126,7 @@ int ConcatInt8CPUKernel::DoExecute(int task_id) {
   if (real_dst_count <= 0) {
     return lite::RET_OK;
   }
-  Concat(input_data_, output_data_, concat_param_, axis_, real_dst_count, task_id);
+  Int8Concat(input_data_, output_data_, concat_param_, axis_, real_dst_count, task_id);
   return lite::RET_OK;
 }
 }  // namespace mindspore::kernel

mindspore/lite/src/runtime/kernel/arm/int8/depth_to_space_int8.cc

@@ -65,7 +65,7 @@ int DepthToSpaceInt8CPUKernel::Run() {
   if (in_quant_arg_.scale_ == out_quant_arg_.scale_ && in_quant_arg_.zp_ == out_quant_arg_.zp_) {
     DepthToSpaceForNHWC(input_data, output_data, in_shape.data(), param);
   } else {
-    DepthToSpaceForNHWC(input_data, output_data, in_shape.data(), param, &in_quant_arg_, &out_quant_arg_);
+    DepthToSpaceForNHWCInt8(input_data, output_data, in_shape.data(), param, &in_quant_arg_, &out_quant_arg_);
   }
   return RET_OK;
 }

mindspore/lite/src/runtime/kernel/arm/int8/reshape_int8.cc

@@ -78,7 +78,7 @@ int ReshapeInt8CPUKernel::DoExecute(int task_id) {
   int8_t *cur_input0_data = input_data_ + task_id * count_unit_;
   int8_t *cur_output_data = output_data_ + task_id * count_unit_;
 
-  Reshape(cur_input0_data, cur_output_data, real_dst_count, reshape_param_->quant_para_);
+  Int8Reshape(cur_input0_data, cur_output_data, real_dst_count, reshape_param_->quant_para_);
   return lite::RET_OK;
 }
 }  // namespace mindspore::kernel

mindspore/lite/src/runtime/kernel/arm/int8/sigmoid_int8.h

@@ -25,8 +25,8 @@ namespace mindspore::kernel {
 class SigmoidInt8CPUKernel : public LiteKernel {
  public:
   SigmoidInt8CPUKernel(OpParameter *parameter, const std::vector<lite::tensor::Tensor *> &inputs,
-                      const std::vector<lite::tensor::Tensor *> &outputs, const lite::Context *ctx,
-                      const lite::Primitive *primitive)
+                       const std::vector<lite::tensor::Tensor *> &outputs, const lite::Context *ctx,
+                       const lite::Primitive *primitive)
       : LiteKernel(parameter, inputs, outputs, ctx, primitive) {}
   ~SigmoidInt8CPUKernel() override = default;
 

mindspore/lite/src/runtime/kernel/arm/int8/softmax_int8.cc

@@ -100,7 +100,7 @@ int SoftmaxInt8CPUKernel::DoSoftmax(int task_id) {
   output_ptr += stride * task_id * inner_size;
   exp_data_ += stride * task_id * inner_size;
 
-  auto error_code = Softmax(input_ptr, output_ptr, count, exp_data_, sum_data_, quant_params_, softmax_param_);
+  auto error_code = Int8Softmax(input_ptr, output_ptr, count, exp_data_, sum_data_, quant_params_, softmax_param_);
   if (error_code != RET_OK) {
     MS_LOG(ERROR) << "DoSoftmax error task_id[" << task_id << "] error_code[" << error_code << "]";
     return RET_ERROR;

mindspore/lite/src/runtime/kernel/arm/int8/softmax_int8.h

@@ -28,9 +28,7 @@ class SoftmaxInt8CPUKernel : public SoftmaxBaseCPUKernel {
                        const std::vector<lite::tensor::Tensor *> &outputs, const lite::Context *ctx,
                        const lite::Primitive *primitive)
       : SoftmaxBaseCPUKernel(parameter, inputs, outputs, ctx, primitive) {}
-  ~SoftmaxInt8CPUKernel() {
-    FreeTmpBuffer();
-  }
+  ~SoftmaxInt8CPUKernel() { FreeTmpBuffer(); }
 
   int Init() override;
   int ReSize() override;

mindspore/lite/src/runtime/kernel/arm/int8/split_int8.cc

@@ -62,8 +62,8 @@ int SplitInt8CPUKernel::Split(int task_id) {
     return RET_OK;
   }
   int thread_offset = task_id * thread_n_stride_;
-  auto ret =
-    DoSplit(input_ptr_, output_ptr_.data(), in_tensors_.front()->shape().data(), thread_offset, num_unit_thread, param);
+  auto ret = Int8DoSplit(input_ptr_, output_ptr_.data(), in_tensors_.front()->shape().data(), thread_offset,
+                         num_unit_thread, param);
   if (ret != RET_OK) {
     MS_LOG(ERROR) << "Split error task_id[" << task_id << "] error_code[" << ret << "]";
     return RET_ERROR;

mindspore/lite/src/runtime/kernel/arm/int8/unsqueeze_int8.cc

@@ -65,7 +65,7 @@ int Unsqueezeint8CPUKernel::DoUnsqueeze(int task_id) {
   auto output_ptr = reinterpret_cast<int8_t *>(out_tensors_.front()->Data());
   size_t data_size = out_tensors_.front()->Size();
 
-  int ret = Unsqueeze(input_ptr, output_ptr, Unsq_para_, data_size, task_id);
+  int ret = Int8Unsqueeze(input_ptr, output_ptr, Unsq_para_, data_size, task_id);
   if (ret != RET_OK) {
     MS_LOG(ERROR) << "UnsqueezeRun error task_id[" << task_id << "] error_code[" << ret << "]";
     return ret;