fix compile errors and add assert test

paddle/framework/tensor.h

@@ -20,7 +20,6 @@ limitations under the License. */
 #include "paddle/framework/ddim.h"
 #include "paddle/framework/enforce.h"
 #include "paddle/memory/memory.h"
-#include "paddle/platform/assert.h"
 #include "paddle/platform/place.h"
 
 namespace paddle {
@@ -63,21 +62,35 @@ class Tensor {
 
   template <typename T>
   struct PlaceholderImpl : public Placeholder {
-    PlaceholderImpl(paddle::platform::Place pl, size_t size)
-        : ptr_(paddle::memory::Alloc(pl, size), paddle::memory::Deleter(pl)),
-          place_(pl),
+   private:
+    class Deleter {
+     public:
+      Deleter(platform::Place place) : place_(place) {}
+      void operator()(T* ptr) {
+        paddle::memory::Free(place_, static_cast<void*>(ptr));
+      }
+
+     private:
+      paddle::platform::Place place_;
+    };
+
+   public:
+    PlaceholderImpl(paddle::platform::Place place, size_t size)
+        : ptr_(static_cast<T*>(paddle::memory::Alloc(place, size)),
+               Deleter(place)),
+          place_(place),
           size_(size) {}
 
     virtual void* Ptr() const { return static_cast<void*>(ptr_.get()); }
     virtual size_t Size() const { return size_; }
     virtual paddle::platform::Place Place() const { return place_; }
 
-    std::unique_ptr<T, memory::Deleter> ptr_;
+    std::unique_ptr<T, Deleter> ptr_;
     paddle::platform::Place place_;  // record the place of ptr_.
     size_t size_;                    // size of the memory block.
   };
 
-  std::unique_ptr<Placeholder> holder_;  // holds the memory block if allocated.
+  std::shared_ptr<Placeholder> holder_;  // holds the memory block if allocated.
 };
 
 }  // namespace framework

paddle/framework/tensor_test.cc

@@ -13,12 +13,23 @@
 
 #include "paddle/framework/tensor.h"
 #include <gtest/gtest.h>
+#include <string>
 
-TEST(Tensor, Data) {
-  using namespace paddle::framework;
-  using namespace paddle::platform;
+TEST(Tensor, ASSERT) {
+  paddle::framework::Tensor cpu_tensor;
 
-  Tensor cpu_tensor;
+  bool caught = false;
+  try {
+    const double* p __attribute__((unused)) = cpu_tensor.data<double>();
+  } catch (paddle::framework::EnforceNotMet err) {
+    caught = true;
+    std::string msg = "Tensor::data must be called after Tensor::mutable_data";
+    const char* what = err.what();
+    for (size_t i = 0; i < msg.length(); ++i) {
+      ASSERT_EQ(what[i], msg[i]);
+    }
+  }
+  ASSERT_TRUE(caught);
 }
 
 /* mutable_data() is not tested at present
@@ -27,7 +38,7 @@ TEST(Tensor, Data) {
 TEST(Tensor, MutableData) {
   using namespace paddle::framework;
   using namespace paddle::platform;
-
+  {
     Tensor cpu_tensor;
     float* p1 = nullptr;
     float* p2 = nullptr;
@@ -47,7 +58,9 @@ TEST(Tensor, MutableData) {
     // momery block is supposed to be unchanged
     p2 = cpu_tensor.mutable_data<float>(make_ddim({2, 2}));
     EXPECT_EQ(p1, p2);
+  }
 
+  {
     Tensor gpu_tensor;
     float* p1 = nullptr;
     float* p2 = nullptr;
@@ -68,4 +81,5 @@ TEST(Tensor, MutableData) {
     p2 = gpu_tensor.mutable_data<float>(make_ddim({2, 2}));
     EXPECT_EQ(p1, p2);
   }
+}
 */