clean_code_8

mindspore/lite/src/common/file_utils.cc

@@ -28,15 +28,15 @@ char *ReadFile(const char *file, size_t *size) {
     return nullptr;
   }
   MS_ASSERT(size != nullptr);
-  std::string realPath = RealPath(file);
+  std::string real_path = RealPath(file);
-  std::ifstream ifs(realPath);
+  std::ifstream ifs(real_path);
   if (!ifs.good()) {
-    MS_LOG(ERROR) << "file: " << realPath << " is not exist";
+    MS_LOG(ERROR) << "file: " << real_path << " is not exist";
     return nullptr;
   }
 
   if (!ifs.is_open()) {
-    MS_LOG(ERROR) << "file: " << realPath << " open failed";
+    MS_LOG(ERROR) << "file: " << real_path << " open failed";
     return nullptr;
   }
 
@@ -44,7 +44,7 @@ char *ReadFile(const char *file, size_t *size) {
   *size = ifs.tellg();
   std::unique_ptr<char[]> buf(new (std::nothrow) char[*size]);
   if (buf == nullptr) {
-    MS_LOG(ERROR) << "malloc buf failed, file: " << realPath;
+    MS_LOG(ERROR) << "malloc buf failed, file: " << real_path;
     ifs.close();
     return nullptr;
   }
@@ -65,21 +65,21 @@ std::string RealPath(const char *path) {
     MS_LOG(ERROR) << "path is too long";
     return "";
   }
-  auto resolvedPath = std::make_unique<char[]>(PATH_MAX);
+  auto resolved_path = std::make_unique<char[]>(PATH_MAX);
-  if (resolvedPath == nullptr) {
+  if (resolved_path == nullptr) {
-    MS_LOG(ERROR) << "new resolvedPath failed";
+    MS_LOG(ERROR) << "new resolved_path failed";
     return "";
   }
 #ifdef _WIN32
-  char *real_path = _fullpath(resolvedPath.get(), path, 1024);
+  char *real_path = _fullpath(resolved_path.get(), path, 1024);
 #else
-  char *real_path = realpath(path, resolvedPath.get());
+  char *real_path = realpath(path, resolved_path.get());
 #endif
   if (real_path == nullptr || strlen(real_path) == 0) {
     MS_LOG(ERROR) << "file path is not valid : " << path;
     return "";
   }
-  std::string res = resolvedPath.get();
+  std::string res = resolved_path.get();
   return res;
 }
 }  // namespace lite

mindspore/lite/src/common/log_adapter.cc

@@ -26,7 +26,7 @@
 namespace mindspore {
 constexpr const char *ANDROID_LOG_TAG = "MS_LITE";
 
-int EnvToInt(const char *env) {
+int StrToInt(const char *env) {
   if (env == nullptr) return 2;
   if (strcmp(env, "0") == 0) return 0;
   if (strcmp(env, "1") == 0) return 1;
@@ -37,7 +37,7 @@ int EnvToInt(const char *env) {
 
 bool IsPrint(int level) {
   static const char *env = std::getenv("GLOG_v");
-  static int ms_level = EnvToInt(env);
+  static int ms_level = StrToInt(env);
   if (level < 0) {
     level = 2;
   }

mindspore/lite/src/common/utils.cc

@@ -48,11 +48,11 @@ uint64_t GetTimeUs() {
     return 0;
   }
   // USECS_IN_SEC *NSECS_IN_USEC;
-  auto retval = static_cast<uint64_t>((ts.tv_sec * USEC) + (ts.tv_nsec / MSEC));
+  auto ret_val = static_cast<uint64_t>((ts.tv_sec * USEC) + (ts.tv_nsec / MSEC));
-  return retval;
+  return ret_val;
 }
 
-std::string Remove(const std::string &from, const std::string &subStr, Mode mode) {
+std::string RemoveSubStr(const std::string &from, const std::string &subStr, RemoveSubStrMode mode) {
   std::string result = from;
   if (mode == PREFIX) {
     if (from.substr(0, subStr.length()) == subStr) {
@@ -90,8 +90,8 @@ std::vector<std::string> StrSplit(const std::string &str, const std::string &pat
 }
 
 std::vector<std::string> Tokenize(const std::string &src, const std::string &delimiters,
-                                  const Option<size_t> &maxTokenNum) {
+                                  const Option<size_t> &max_token_num) {
-  if (maxTokenNum.IsSome() && maxTokenNum.Get() == 0) {
+  if (max_token_num.IsSome() && max_token_num.Get() == 0) {
     return {};
   }
 
@@ -104,7 +104,7 @@ std::vector<std::string> Tokenize(const std::string &src, const std::string &del
       break;
     }
     size_t delimiter = src.find_first_of(delimiters, nonDelimiter);
-    if (delimiter == std::string::npos || (maxTokenNum.IsSome() && tokens.size() == maxTokenNum.Get() - 1)) {
+    if (delimiter == std::string::npos || (max_token_num.IsSome() && tokens.size() == max_token_num.Get() - 1)) {
       tokens.push_back(src.substr(nonDelimiter));
       break;
     }

mindspore/lite/src/common/utils.h

@@ -148,10 +148,10 @@ std::vector<std::string> StrSplit(const std::string &str, const std::string &pat
 std::vector<std::string> Tokenize(const std::string &src, const std::string &delimiters,
                                   const Option<size_t> &maxTokenNum = Option<size_t>(None()));
 
-enum Mode { PREFIX, SUFFIX, ANY };
+enum RemoveSubStrMode { PREFIX, SUFFIX, ANY };
 
 // remove redundant charactor
-std::string Remove(const std::string &from, const std::string &subStr, Mode mode = ANY);
+std::string RemoveSubStr(const std::string &from, const std::string &subStr, RemoveSubStrMode mode = ANY);
 
 template <typename T>
 inline Option<T> GenericParseValue(const std::string &value) {

mindspore/lite/src/kernel_registry.cc

@@ -95,7 +95,7 @@ void KernelRegistry::RegKernel(const KERNEL_ARCH arch, const TypeId data_type, c
   creator_arrays_[index] = creator;
 }
 
-bool KernelRegistry::Merge(const std::unordered_map<KernelKey, KernelCreator> &newCreators) { return false; }
+bool KernelRegistry::Merge(const std::unordered_map<KernelKey, KernelCreator> &new_creators) { return false; }
 
 const kernel::KernelCreator *KernelRegistry::GetCreatorArrays() { return creator_arrays_; }
 

mindspore/lite/src/lite_kernel.cc

@@ -26,7 +26,9 @@ using mindspore::lite::RET_OK;
 void *LiteKernel::workspace_ = nullptr;
 
 void LiteKernel::AllocWorkspace(size_t size) {
-  if (size == 0) return;
+  if (size == 0) {
+    return;
+  }
   workspace_ = malloc(size);
   if (workspace_ == nullptr) {
     MS_LOG(ERROR) << "fail to alloc " << size;
@@ -74,10 +76,10 @@ int LiteKernel::FreeWorkTensor() const {
 
 int LiteKernel::PreProcess() {
   if (!InferShapeDone()) {
-    (const_cast<mindspore::lite::PrimitiveC *>(primitive_))->SetInferFlag(true);
+    (const_cast<mindspore::lite::PrimitiveC *>(primitive_))->set_infer_flag(true);
     auto ret = (const_cast<mindspore::lite::PrimitiveC *>(primitive_))->InferShape(in_tensors_, out_tensors_);
     if (ret != 0) {
-      (const_cast<mindspore::lite::PrimitiveC *>(primitive_))->SetInferFlag(false);
+      (const_cast<mindspore::lite::PrimitiveC *>(primitive_))->set_infer_flag(false);
       MS_LOG(ERROR) << "InferShape fail!";
       return ret;
     }
@@ -279,8 +281,8 @@ int LiteKernelUtil::TopologicalSortKernels(std::vector<kernel::LiteKernel *> *ke
 void LiteKernelUtil::InitIOKernels(std::vector<kernel::LiteKernel *> &kernels) {
   for (auto *kernel : kernels) {
     // clean io kernels
-    kernel->SetInKernel({});
+    kernel->set_in_kernel({});
-    kernel->SetOutKernel({});
+    kernel->set_out_kernel({});
     // find io kernels
     for (auto *search_kernel : kernels) {
       if (search_kernel == kernel) {

mindspore/lite/src/lite_kernel.h

@@ -109,9 +109,9 @@ class LiteKernel {
 
   virtual bool IsEval() const { return !this->train_mode_; }
 
-  virtual void SetTrainable(bool trainable = true) { this->trainable_ = trainable; }
+  virtual void set_trainable(bool trainable = true) { this->trainable_ = trainable; }
 
-  virtual bool IsTrainable() const { return this->trainable_; }
+  virtual bool is_trainable() const { return this->trainable_; }
 
   void set_name(const std::string &name) { this->name_ = name; }
 
@@ -146,9 +146,9 @@ class LiteKernel {
     }
   }
 
-  void SetInKernel(const std::vector<LiteKernel *> &kernel) { this->in_kernels_ = kernel; }
+  void set_in_kernel(const std::vector<LiteKernel *> &kernel) { this->in_kernels_ = kernel; }
 
-  void SetOutKernel(const std::vector<LiteKernel *> &kernel) { this->out_kernels_ = kernel; }
+  void set_out_kernel(const std::vector<LiteKernel *> &kernel) { this->out_kernels_ = kernel; }
 
   const std::vector<LiteKernel *> &in_kernels() const { return this->in_kernels_; }
 
@@ -165,18 +165,18 @@ class LiteKernel {
   void set_desc(const KernelKey kernel_key) { desc_ = kernel_key; }
 
   const mindspore::lite::PrimitiveC *GetPrimitive() const { return primitive_; }
-  void SetWorkspaceSize(size_t value) { workspace_size_ = value; }
+  void set_workspace_size(size_t value) { workspace_size_ = value; }
-  size_t GetWorkspaceSize() { return workspace_size_; }
+  size_t workspace_size() { return workspace_size_; }
   static void AllocWorkspace(size_t size);
   static void FreeWorkspace();
-  void *GetWorkspace() { return workspace_; }
+  void *workspace() { return workspace_; }
 
   SubGraphType subgraph_type() const { return this->subgraph_type_; }
 
   virtual std::string ToString() const;
 
  protected:
-  bool InferShapeDone() { return !(primitive_ != nullptr && !primitive_->GetInferFlag()); }
+  bool InferShapeDone() { return !(primitive_ != nullptr && !primitive_->infer_flag()); }
 
   KernelKey desc_{};
   std::string name_;

mindspore/lite/src/lite_session.cc

@@ -74,7 +74,7 @@ void LiteSession::ConvertTensorsQuantParam(const schema::Tensor *src_tensor, lit
     for (size_t j = 0; j < quant_clusters->size(); j++) {
       clusters.push_back(quant_clusters->Get(j));
     }
-    dst_tensor->SetQuantClusters(clusters);
+    dst_tensor->set_quant_clusters(clusters);
   }
 }
 

mindspore/lite/src/model_common.h

@@ -32,7 +32,7 @@ namespace mindspore::lite {
 int ConvertSubGraph(const schema::SubGraph &sub_graph, Model *model);
 
 template <typename T = schema::MetaGraph, typename U = schema::CNode>
-bool ConvertNodes(const T &meta_graph, Model *model, int schema_version = 0) {
+bool ConvertNodes(const T &meta_graph, Model *model, int schema_version = SCHEMA_CUR) {
   MS_ASSERT(model != nullptr);
   for (size_t i = 0; i < meta_graph.nodes()->size(); ++i) {
     auto *node = new (std::nothrow) Model::Node();
@@ -53,7 +53,7 @@ bool ConvertNodes(const T &meta_graph, Model *model, int schema_version = 0) {
       delete node;
       return false;
     }
-    node->primitive_->SetQuantType(static_cast<schema::QuantType>(c_node->quantType()));
+    node->primitive_->set_quant_type(static_cast<schema::QuantType>(c_node->quantType()));
     node->name_ = c_node->name()->c_str();
     node->node_type_ = static_cast<NodeType>(c_node->nodeType());
     auto count = c_node->inputIndex()->size();

mindspore/lite/src/ops/adam.cc

@@ -88,7 +88,7 @@ int Adam::InferShape(std::vector<lite::Tensor *> inputs, std::vector<lite::Tenso
     auto *out = outputs.front();
     MS_ASSERT(out != nullptr);
     out->set_data_type(inputs[0]->data_type());
-    out->SetFormat(inputs[0]->GetFormat());
+    out->set_format(inputs[0]->format());
     out->set_shape({1});
   }
 

mindspore/lite/src/ops/addn.cc

@@ -83,9 +83,9 @@ int AddN::InferShape(std::vector<Tensor *> inputs, std::vector<Tensor *> outputs
     MS_LOG(ERROR) << "input size" << inputs.size() << " is error!";
     return RET_INPUT_TENSOR_ERROR;
   }
-  output->SetFormat(input->GetFormat());
+  output->set_format(input->format());
   output->set_data_type(input->data_type());
-  if (!GetInferFlag()) {
+  if (!infer_flag()) {
     return RET_OK;
   }
   output->set_shape(input->shape());

mindspore/lite/src/ops/apply_momentum.cc

@@ -93,7 +93,7 @@ int ApplyMomentum::InferShape(std::vector<lite::Tensor *> inputs, std::vector<li
     auto *out = outputs.front();
     MS_ASSERT(out != nullptr);
     out->set_data_type(inputs[0]->data_type());
-    out->SetFormat(inputs[0]->GetFormat());
+    out->set_format(inputs[0]->format());
     out->set_shape({1});
   }
 

mindspore/lite/src/ops/argmax.cc

@@ -71,9 +71,9 @@ int ArgMax::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> outp
     return RET_ERROR;
   }
 
-  output->SetFormat(input->GetFormat());
+  output->set_format(input->format());
   output->set_data_type(input->data_type());
-  if (!GetInferFlag()) {
+  if (!infer_flag()) {
     return RET_OK;
   }
   std::vector<int> output_shape(input->shape());

mindspore/lite/src/ops/argmin.cc

@@ -69,9 +69,9 @@ int ArgMin::InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Te
   if (inputs_.size() != kSingleNum || outputs_.size() != kSingleNum) {
     MS_LOG(ERROR) << "tensor number is error.";
   }
-  output->SetFormat(input->GetFormat());
+  output->set_format(input->format());
   output->set_data_type(input->data_type());
-  if (!GetInferFlag()) {
+  if (!infer_flag()) {
     return RET_OK;
   }
   auto input_shape_size = input->shape().size();

mindspore/lite/src/ops/arithmetic.cc

@@ -41,10 +41,10 @@ int Arithmetic::InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite
 
   auto input_shape0 = input0->shape();
   auto input_shape1 = input1->shape();
-  auto format = input0->GetFormat();
+  auto format = input0->format();
-  output->SetFormat(format);
+  output->set_format(format);
   output->set_data_type(input0->data_type());
-  if (!GetInferFlag()) {
+  if (!infer_flag()) {
     return RET_OK;
   }
   if (input_shape0.size() > 10 || input_shape1.size() > 10) {
@@ -69,7 +69,7 @@ int Arithmetic::InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite
       }
       in_shape1_[i] = input_shape1[i];
     }
-    format = input0->GetFormat();
+    format = input0->format();
   } else if (input_shape0.size() > input_shape1.size()) {
     ndim_ = input_shape0.size();
     auto fill_dim_num = input_shape0.size() - input_shape1.size();

mindspore/lite/src/ops/arithmetic_self.cc

@@ -30,9 +30,9 @@ int ArithmeticSelf::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor
   MS_ASSERT(input != nullptr);
   auto output = outputs_.front();
   MS_ASSERT(output != nullptr);
-  output->SetFormat(input->GetFormat());
+  output->set_format(input->format());
   output->set_data_type(input->data_type());
-  if (!GetInferFlag()) {
+  if (!infer_flag()) {
     return RET_OK;
   }
   output->set_shape(input->shape());

mindspore/lite/src/ops/assign.cc

@@ -80,7 +80,7 @@ int Assign::InferShape(std::vector<lite::Tensor *> inputs, std::vector<lite::Ten
     auto *out = outputs.front();
     MS_ASSERT(out != nullptr);
     out->set_data_type(inputs[0]->data_type());
-    out->SetFormat(inputs[0]->GetFormat());
+    out->set_format(inputs[0]->format());
     out->set_shape({1});
   }
   return RET_OK;

mindspore/lite/src/ops/assign_add.cc

@@ -86,7 +86,7 @@ int AssignAdd::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> o
     output_shape[i] = x_shape[i];
   }
   out->set_shape(output_shape);
-  out->SetFormat(x->GetFormat());
+  out->set_format(x->format());
   out->set_data_type(x->data_type());
   return RET_OK;
 }

mindspore/lite/src/ops/audio_spectrogram.cc

@@ -75,8 +75,8 @@ int AudioSpectrogram::InferShape(std::vector<Tensor *> inputs_, std::vector<Tens
   auto output = outputs_.front();
   MS_ASSERT(output != nullptr);
   output->set_data_type(input->data_type());
-  output->SetFormat(input->GetFormat());
+  output->set_format(input->format());
-  if (!GetInferFlag()) {
+  if (!infer_flag()) {
     return RET_OK;
   }
   auto input_shape = input->shape();

mindspore/lite/src/ops/batch_to_space.cc

@@ -91,13 +91,13 @@ int BatchToSpace::InferShape(std::vector<lite::Tensor *> inputs, std::vector<lit
   }
 
   auto input = inputs.at(0);
-  if (input->GetFormat() != schema::Format::Format_NHWC) {
+  if (input->format() != schema::Format::Format_NHWC) {
     MS_LOG(ERROR) << "batch_to_space only support NHWC now!";
     return RET_FORMAT_ERR;
   }
-  outputs[0]->SetFormat(input->GetFormat());
+  outputs[0]->set_format(input->format());
   outputs[0]->set_data_type(input->data_type());
-  if (!GetInferFlag()) {
+  if (!infer_flag()) {
     return RET_OK;
   }
   auto input_shape = input->shape();

mindspore/lite/src/ops/bias_grad.cc

@@ -111,7 +111,7 @@ int BiasGrad::InferShape(std::vector<Tensor *> inputs, std::vector<Tensor *> out
   }
   out->set_shape(inshape);
   out->set_data_type(in0->data_type());
-  out->SetFormat(in0->GetFormat());
+  out->set_format(in0->format());
 
   return RET_OK;
 }

mindspore/lite/src/ops/binary_cross_entropy.cc

@@ -102,7 +102,7 @@ Registry BinaryCrossEntropyRegistry(schema::PrimitiveType_BinaryCrossEntropy, Bi
 int BinaryCrossEntropy::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> outputs_) {
   Tensor *x = inputs_[0];
   Tensor *out = outputs_[0];
-  out->SetFormat(x->GetFormat());
+  out->set_format(x->format());
   out->set_data_type(x->data_type());
   int reduction = GetReduction();
   if (reduction == 1 || reduction == 2) {

mindspore/lite/src/ops/binary_cross_entropy_grad.cc

@@ -109,7 +109,7 @@ Registry BinaryCrossEntropyGradRegistry(schema::PrimitiveType_BinaryCrossEntropy
 int BinaryCrossEntropyGrad::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> outputs_) {
   Tensor *x = inputs_[0];
   Tensor *out = outputs_[0];
-  out->SetFormat(x->GetFormat());
+  out->set_format(x->format());
   out->set_data_type(x->data_type());
   std::vector<int> x_shape = x->shape();
   std::vector<int> output_shape(x_shape.size());

mindspore/lite/src/ops/bn_grad.cc

@@ -106,9 +106,9 @@ int BNGrad::InferShape(std::vector<lite::Tensor *> inputs, std::vector<lite::Ten
   outputs[0]->set_data_type(in->data_type());
   outputs[1]->set_data_type(scale->data_type());
   outputs[2]->set_data_type(scale->data_type());
-  outputs[0]->SetFormat(in->GetFormat());
+  outputs[0]->set_format(in->format());
-  outputs[1]->SetFormat(scale->GetFormat());
+  outputs[1]->set_format(scale->format());
-  outputs[2]->SetFormat(scale->GetFormat());
+  outputs[2]->set_format(scale->format());
   return RET_OK;
 }
 }  // namespace lite

mindspore/lite/src/ops/broadcast_to.cc

@@ -77,9 +77,9 @@ int BroadcastTo::InferShape(std::vector<Tensor *> inputs, std::vector<Tensor *>
   }
 
   auto input = inputs.at(0);
-  outputs[0]->SetFormat(input->GetFormat());
+  outputs[0]->set_format(input->format());
   outputs[0]->set_data_type(input->data_type());
-  if (!GetInferFlag()) {
+  if (!infer_flag()) {
     return RET_OK;
   }
   std::vector<int32_t> dst_shape(GetDstShape());