Perfect unitests (PaddlePaddle#16)

* perfect unittest

* update license

paddle/fluid/framework/CMakeLists.txt

@@ -390,7 +390,7 @@ cc_library(save_load_util SRCS save_load_util.cc DEPS tensor scope layer)
 cc_test(save_load_util_test SRCS save_load_util_test.cc DEPS save_load_util tensor scope layer)
 cc_library(generator SRCS generator.cc DEPS enforce place)
 
-cc_library(tcmpt_utils SRCS tcmpt_utils.cc DEPS lod_tensor selected_rows place tcmpt)
+cc_library(tcmpt_utils SRCS tcmpt_utils.cc DEPS lod_tensor selected_rows place tcmpt var_type_traits)
 
 # Get the current working branch
 execute_process(
@@ -454,3 +454,4 @@ if(WITH_TESTING AND TEST selected_rows_test)
 endif()
 
 cc_test(scope_guard_test SRCS scope_guard_test.cc)
+cc_test(tcmpt_utils_test SRCS tcmpt_utils_test.cc DEPS tcmpt_utils)

paddle/fluid/framework/tcmpt_utils.cc

@@ -74,20 +74,6 @@ std::shared_ptr<pt::DenseTensor> MakeTensorImpl<pt::DenseTensor>(
       pt::TransToPtLayout(tensor.layout()));
 }
 
-template <>
-void ShareTensorImpl<pt::DenseTensor>(pt::DenseTensor* tensor_impl,
-                                      LoDTensor* out) {
-  out->ResetHolderWithType(tensor_impl->allocation(),
-                           pt::TransToProtoVarType(tensor_impl->type()));
-}
-
-template <>
-void ShareTensorImpl<pt::DenseTensor>(pt::DenseTensor* tensor_impl,
-                                      Tensor* out) {
-  out->ResetHolderWithType(tensor_impl->allocation(),
-                           pt::TransToProtoVarType(tensor_impl->type()));
-}
-
 std::shared_ptr<pt::TensorInterface> InputVariableToPtTensor(
     const framework::Variable& variable, const pt::TensorArgDef& arg_def) {
   auto expected_place = pt::TransToFluidPlace(arg_def.backend);

paddle/fluid/framework/tcmpt_utils.h

@@ -38,12 +38,6 @@ std::shared_ptr<PtTensorImplT> MakeTensorImpl(const Tensor& tensor,
                                               const platform::Place& place,
                                               proto::VarType::Type type);
 
-template <typename PtTensorImplT>
-void ShareTensorImpl(PtTensorImplT* tensor_impl, LoDTensor* out);
-
-template <typename PtTensorImplT>
-void ShareTensorImpl(PtTensorImplT* tensor_impl, Tensor* out);
-
 std::shared_ptr<pt::TensorInterface> InputVariableToPtTensor(
     const framework::Variable& variable, const pt::TensorArgDef& arg_def);
 std::shared_ptr<pt::TensorInterface> OutputVariableToPtTensor(

paddle/fluid/framework/tcmpt_utils_test.cc

@@ -0,0 +1,62 @@
+/* Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+#include "paddle/fluid/framework/tcmpt_utils.h"
+#include "gtest/gtest.h"
+#include "paddle/fluid/framework/lod_tensor.h"
+#include "paddle/fluid/framework/selected_rows.h"
+#include "paddle/fluid/framework/variable.h"
+
+namespace paddle {
+namespace framework {
+
+TEST(TcmptUtils, MakeTensor) {
+  // 1. create tensor
+  LoDTensor x;
+  Tensor x2;
+  x.Resize({2});
+  x.mutable_data<float>(platform::CPUPlace());
+  x.data<float>()[0] = 0.2;
+  x.data<float>()[1] = 0.5;
+
+  // 2. test API
+  auto dense_x = MakeTensorImpl<pt::DenseTensor>(x, x.place(), x.type());
+
+  // 3. check result
+  std::vector<float> expect_value = {0.2, 0.5};
+  ASSERT_EQ(dense_x->data<float>()[0], expect_value[0]);
+  ASSERT_EQ(dense_x->data<float>()[1], expect_value[1]);
+  ASSERT_EQ(dense_x->backend(), pt::Backend::kCPU);
+  ASSERT_EQ(dense_x->type(), pt::DataType::kFLOAT32);
+}
+
+TEST(TcmptUtils, VarToPtTensor) {
+  // 1. create Variable
+  Variable v;
+  auto selected_rows = v.GetMutable<SelectedRows>();
+  Tensor* value = selected_rows->mutable_value();
+  auto* data =
+      value->mutable_data<int>(make_ddim({1, 1}), paddle::platform::CPUPlace());
+  data[0] = 123;
+  auto tensor_def = pt::TensorArgDef(pt::Backend::kCUDA, pt::DataLayout::kNCHW,
+                                     pt::DataType::kINT32);
+  // 2. test API
+  auto tensor_x = InputVariableToPtTensor(v, tensor_def);
+  // 3. check result
+  ASSERT_EQ(tensor_x->backend(), pt::Backend::kCUDA);
+  ASSERT_EQ(tensor_x->type(), pt::DataType::kINT32);
+}
+
+}  // namespace framework
+}  // namespace paddle