clean_code_for_master

mindspore/lite/src/common/utils.cc

@@ -52,20 +52,20 @@ uint64_t GetTimeUs() {
   return ret_val;
 }
 
-std::string RemoveSubStr(const std::string &from, const std::string &subStr, RemoveSubStrMode mode) {
+std::string RemoveSubStr(const std::string &from, const std::string &sub_str, RemoveSubStrMode mode) {
   std::string result = from;
   if (mode == PREFIX) {
-    if (from.substr(0, subStr.length()) == subStr) {
-      result = from.substr(subStr.size());
+    if (from.substr(0, sub_str.length()) == sub_str) {
+      result = from.substr(sub_str.size());
     }
   } else if (mode == SUFFIX) {
-    if (from.rfind(subStr) == from.size() - subStr.size()) {
-      result = from.substr(0, from.size() - subStr.size());
+    if (from.rfind(sub_str) == from.size() - sub_str.size()) {
+      result = from.substr(0, from.size() - sub_str.size());
     }
   } else {
     size_t index;
-    while ((index = result.find(subStr)) != std::string::npos) {
-      result = result.erase(index, subStr.size());
+    while ((index = result.find(sub_str)) != std::string::npos) {
+      result = result.erase(index, sub_str.size());
     }
   }
 

mindspore/lite/src/common/utils.h

@@ -151,7 +151,7 @@ std::vector<std::string> Tokenize(const std::string &src, const std::string &del
 enum RemoveSubStrMode { PREFIX, SUFFIX, ANY };
 
 // remove redundant charactor
-std::string RemoveSubStr(const std::string &from, const std::string &subStr, RemoveSubStrMode mode = ANY);
+std::string RemoveSubStr(const std::string &from, const std::string &sub_str, RemoveSubStrMode mode = ANY);
 
 template <typename T>
 inline Option<T> GenericParseValue(const std::string &value) {

mindspore/lite/src/lite_kernel.cc

@@ -281,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->set_in_kernel({});
-    kernel->set_out_kernel({});
+    kernel->set_in_kernels({});
+    kernel->set_out_kernels({});
     // find io kernels
     for (auto *search_kernel : kernels) {
       if (search_kernel == kernel) {

mindspore/lite/src/lite_kernel.h

@@ -146,9 +146,9 @@ class LiteKernel {
     }
   }
 
-  void set_in_kernel(const std::vector<LiteKernel *> &kernel) { this->in_kernels_ = kernel; }
+  void set_in_kernels(const std::vector<LiteKernel *> &kernel) { this->in_kernels_ = kernel; }
 
-  void set_out_kernel(const std::vector<LiteKernel *> &kernel) { this->out_kernels_ = kernel; }
+  void set_out_kernels(const std::vector<LiteKernel *> &kernel) { this->out_kernels_ = kernel; }
 
   const std::vector<LiteKernel *> &in_kernels() const { return this->in_kernels_; }
 

mindspore/lite/src/runtime/kernel/opencl/subgraph_opencl_kernel.cc

@@ -53,10 +53,10 @@ void SubGraphOpenCLKernel::ReplaceOutTensorAndKernelToNull(
         nullptr);
       if (mem_type == MemType::IMG) {
         jv->set_in_tensors(tensors);
-        jv->set_in_kernel(kernels);
+        jv->set_in_kernels(kernels);
       } else {
         jv->set_out_tensors(tensors);
-        jv->set_out_kernel(kernels);
+        jv->set_out_kernels(kernels);
       }
     }
   }
@@ -85,11 +85,11 @@ void SubGraphOpenCLKernel::ReplaceOutTensorAndKernelToConvert(const lite::Tensor
       tensors.emplace_back(new_tensor);
     }
     if (mem_type == MemType::IMG) {
-      iv->set_in_kernel(kernels);
+      iv->set_in_kernels(kernels);
       iv->set_in_tensors(tensors);
       in_opencl_op->AddOutKernel(iv);
     } else {
-      iv->set_out_kernel(kernels);
+      iv->set_out_kernels(kernels);
       iv->set_out_tensors(tensors);
       in_convert_op->AddInKernel(iv);
     }