Remove proto from variable name

mace/core/runtime/hexagon/hexagon_control_wrapper.cc

@@ -64,29 +64,29 @@ bool HexagonControlWrapper::SetupGraph(const NetDef &net_def) {
   std::thread const_thread([&]() {
     std::cout << "thread function\n";
     std::vector<hexagon_nn_const_node> const_node_list;
-    for (const ConstTensor &tensor_proto: net_def.tensors()) {
-      std::vector<int> tensor_shape(tensor_proto.dims().begin(),
-                               tensor_proto.dims().end());
+    for (const ConstTensor &const_tensor: net_def.tensors()) {
+      std::vector<int> tensor_shape(const_tensor.dims().begin(),
+                               const_tensor.dims().end());
       while (tensor_shape.size() < 4) {
         tensor_shape.insert(tensor_shape.begin(), 1);
       }
 
       hexagon_nn_const_node const_node;
-      const_node.node_id = node_id(tensor_proto.node_id());
+      const_node.node_id = node_id(const_tensor.node_id());
       const_node.tensor.batches = tensor_shape[0];
       const_node.tensor.height = tensor_shape[1];
       const_node.tensor.width = tensor_shape[2];
       const_node.tensor.depth = tensor_shape[3];
 
-      if (tensor_proto.data_type() == DataType::DT_INT32
-        && tensor_proto.data_size() == 0) {
+      if (const_tensor.data_type() == DataType::DT_INT32
+        && const_tensor.data_size() == 0) {
         const_node.tensor.data = NULL;
         const_node.tensor.dataLen = 0;
       } else {
         const_node.tensor.data =
-          const_cast<unsigned char *>(tensor_proto.data());
+          const_cast<unsigned char *>(const_tensor.data());
         const_node.tensor.dataLen =
-          tensor_proto.data_size() * GetEnumTypeSize(tensor_proto.data_type());
+          const_tensor.data_size() * GetEnumTypeSize(const_tensor.data_type());
       }
       const_node_list.push_back(const_node);
       // 255 is magic number: why fastrpc limits sequence length to that?

mace/core/serializer.cc

@@ -12,56 +12,64 @@ std::unique_ptr<ConstTensor> Serializer::Serialize(const Tensor &tensor,
   return nullptr;
 }
 
-std::unique_ptr<Tensor> Serializer::Deserialize(const ConstTensor &proto,
+std::unique_ptr<Tensor> Serializer::Deserialize(const ConstTensor &const_tensor,
                                                 DeviceType type) {
   std::unique_ptr<Tensor> tensor(
-      new Tensor(GetDeviceAllocator(type), proto.data_type()));
+      new Tensor(GetDeviceAllocator(type), const_tensor.data_type()));
   std::vector<index_t> dims;
-  for (const index_t d : proto.dims()) {
+  for (const index_t d : const_tensor.dims()) {
     dims.push_back(d);
   }
   tensor->Resize(dims);
 
-  switch (proto.data_type()) {
+  switch (const_tensor.data_type()) {
     case DT_HALF:
-      tensor->Copy<half>(reinterpret_cast<const half*>(proto.data()),
-                         proto.data_size());
+      tensor->Copy<half>(reinterpret_cast<const half *>(const_tensor.data()),
+                         const_tensor.data_size());
       break;
     case DT_FLOAT:
-      tensor->Copy<float>(reinterpret_cast<const float *>(proto.data()),
-                          proto.data_size());
+      tensor->Copy<float>(reinterpret_cast<const float *>(const_tensor.data()),
+                          const_tensor.data_size());
       break;
     case DT_DOUBLE:
-      tensor->Copy<double>(reinterpret_cast<const double *>(proto.data()),
-                           proto.data_size());
+      tensor->Copy<double>(
+          reinterpret_cast<const double *>(const_tensor.data()),
+          const_tensor.data_size());
       break;
     case DT_INT32:
-      tensor->Copy<int32_t>(reinterpret_cast<const int32_t *>(proto.data()),
-                            proto.data_size());
+      tensor->Copy<int32_t>(
+          reinterpret_cast<const int32_t *>(const_tensor.data()),
+          const_tensor.data_size());
       break;
     case DT_INT64:
-      tensor->Copy<int64_t>(reinterpret_cast<const int64_t *>(proto.data()),
-                            proto.data_size());
+      tensor->Copy<int64_t>(
+          reinterpret_cast<const int64_t *>(const_tensor.data()),
+          const_tensor.data_size());
       break;
     case DT_UINT8:
-      tensor->Copy<uint8_t>(reinterpret_cast<const uint8_t *>(proto.data()),
-                            proto.data_size());
+      tensor->Copy<uint8_t>(
+          reinterpret_cast<const uint8_t *>(const_tensor.data()),
+          const_tensor.data_size());
       break;
     case DT_INT16:
       tensor->CopyWithCast<int32_t, uint16_t>(
-          reinterpret_cast<const int32_t *>(proto.data()), proto.data_size());
+          reinterpret_cast<const int32_t *>(const_tensor.data()),
+          const_tensor.data_size());
       break;
     case DT_INT8:
       tensor->CopyWithCast<int32_t, int8_t>(
-          reinterpret_cast<const int32_t *>(proto.data()), proto.data_size());
+          reinterpret_cast<const int32_t *>(const_tensor.data()),
+          const_tensor.data_size());
       break;
     case DT_UINT16:
       tensor->CopyWithCast<int32_t, int16_t>(
-          reinterpret_cast<const int32_t *>(proto.data()), proto.data_size());
+          reinterpret_cast<const int32_t *>(const_tensor.data()),
+          const_tensor.data_size());
       break;
     case DT_BOOL:
       tensor->CopyWithCast<int32_t, bool>(
-          reinterpret_cast<const int32_t *>(proto.data()), proto.data_size());
+          reinterpret_cast<const int32_t *>(const_tensor.data()),
+          const_tensor.data_size());
       break;
     default:
       MACE_NOT_IMPLEMENTED;

mace/core/serializer.h

@@ -15,9 +15,11 @@ class Serializer {
   Serializer() {}
   ~Serializer() {}
 
-  std::unique_ptr<ConstTensor> Serialize(const Tensor &tensor, const std::string &name);
+  std::unique_ptr<ConstTensor> Serialize(const Tensor &tensor,
+                                         const std::string &name);
 
-  std::unique_ptr<Tensor> Deserialize(const ConstTensor &proto, DeviceType type);
+  std::unique_ptr<Tensor> Deserialize(const ConstTensor &const_tensor,
+                                      DeviceType type);
 
   DISABLE_COPY_AND_ASSIGN(Serializer);
 };

mace/core/tensor.h

@@ -324,12 +324,12 @@ class Tensor {
         }
       }
     }
+
     MappingGuard(MappingGuard &&other) {
       tensor_ = other.tensor_;
       other.tensor_ = nullptr;
     }
-    MappingGuard(const MappingGuard &other) = delete;
-    MappingGuard & operator = (const MappingGuard &other) = delete;
+
     ~MappingGuard() {
       if (tensor_ != nullptr) tensor_->Unmap();
     }
@@ -339,6 +339,8 @@ class Tensor {
    private:
     const Tensor *tensor_;
     std::vector<size_t> mapped_image_pitch_;
+
+    DISABLE_COPY_AND_ASSIGN(MappingGuard);
   };
 
  private:

mace/core/workspace.cc

@@ -72,15 +72,15 @@ Tensor *Workspace::GetTensor(const std::string &name) {
 void Workspace::LoadModelTensor(const NetDef &net_def, DeviceType type) {
   MACE_LATENCY_LOGGER(1, "Load model tensors");
   Serializer serializer;
-  for (auto &tensor_proto : net_def.tensors()) {
-    MACE_LATENCY_LOGGER(2, "Load tensor ", tensor_proto.name());
-    VLOG(3) << "Tensor name: " << tensor_proto.name()
-            << ", data type: " << tensor_proto.data_type()
+  for (auto &const_tensor : net_def.tensors()) {
+    MACE_LATENCY_LOGGER(2, "Load tensor ", const_tensor.name());
+    VLOG(3) << "Tensor name: " << const_tensor.name()
+            << ", data type: " << const_tensor.data_type()
             << ", shape: "
-            << MakeString(std::vector<index_t>(tensor_proto.dims().begin(),
-                                               tensor_proto.dims().end()));
-    tensor_map_[tensor_proto.name()] =
-        serializer.Deserialize(tensor_proto, type);
+            << MakeString(std::vector<index_t>(const_tensor.dims().begin(),
+                                               const_tensor.dims().end()));
+    tensor_map_[const_tensor.name()] =
+        serializer.Deserialize(const_tensor, type);
   }
   if (type == DeviceType::OPENCL) {
     CreateImageOutputTensor(net_def);