replace use_pinned with is_pinned

paddle/fluid/framework/tensor.h

@@ -45,11 +45,11 @@ class Tensor {
   friend struct EigenVector;
 
  public:
-  Tensor() : offset_(0), use_pinned_(false) {}
+  Tensor() : offset_(0), is_pinned_(false) {}
 
   /*! Constructor with place should only be used in pybind. */
   explicit Tensor(const platform::Place& place)
-      : offset_(0), use_pinned_(false) {
+      : offset_(0), is_pinned_(false) {
     holder_->set_place(place);
   }
 
@@ -70,12 +70,12 @@ class Tensor {
    * @note    If not exist, then allocation.
    */
   template <typename T>
-  inline T* mutable_data(platform::Place place, bool use_pinned = false);
+  inline T* mutable_data(platform::Place place, bool is_pinned = false);
 
   inline void* mutable_data(platform::Place place, std::type_index type,
-                            bool use_pinned = false);
+                            bool is_pinned = false);
 
-  inline void* mutable_data(platform::Place place, bool use_pinned = false);
+  inline void* mutable_data(platform::Place place, bool is_pinned = false);
 
   /**
    * @brief     Return a pointer to mutable memory block.
@@ -87,7 +87,7 @@ class Tensor {
    */
   template <typename T>
   inline T* mutable_data(DDim dims, platform::Place place,
-                         bool use_pinned = false);
+                         bool is_pinned = false);
 
   /*! Return the dimensions of the memory block. */
   inline const DDim& dims() const;
@@ -153,13 +153,13 @@ class Tensor {
   template <typename Place>
   struct PlaceholderImpl : public Placeholder {
     PlaceholderImpl(Place place, size_t size, std::type_index type,
-                    bool use_pinned = false)
-        : ptr_(static_cast<uint8_t*>(memory::Alloc(place, size, use_pinned)),
-               memory::PODDeleter<uint8_t, Place>(place, use_pinned)),
+                    bool is_pinned = false)
+        : ptr_(static_cast<uint8_t*>(memory::Alloc(place, size, is_pinned)),
+               memory::PODDeleter<uint8_t, Place>(place, is_pinned)),
           place_(place),
           size_(size),
           type_(type),
-          use_pinned_(use_pinned) {
+          is_pinned_(is_pinned) {
       PADDLE_ENFORCE_NOT_NULL(ptr_, "Insufficient %s memory to allocation.",
                               (is_cpu_place(place_) ? "CPU" : "GPU"));
     }
@@ -184,7 +184,7 @@ class Tensor {
     std::type_index type_;
 
     /*! use pinned memory or not. */
-    bool use_pinned_;
+    bool is_pinned_;
   };
 
   /*! holds the memory block if allocated. */
@@ -219,7 +219,7 @@ class Tensor {
    *          PlaceHolder::ptr_ and where the tensor data really begins.
    */
   size_t offset_;
-  bool use_pinned_;
+  bool is_pinned_;
 };
 
 inline void Tensor::switch_place(platform::Place new_place) {

paddle/fluid/framework/tensor_impl.h

@@ -102,20 +102,20 @@ inline T* Tensor::data() {
 
 template <typename T>
 inline T* Tensor::mutable_data(DDim dims, platform::Place place,
-                               bool use_pinned) {
+                               bool is_pinned) {
   static_assert(std::is_pod<T>::value, "T must be POD");
   Resize(dims);
-  return mutable_data<T>(place, use_pinned);
+  return mutable_data<T>(place, is_pinned);
 }
 
 template <typename T>
-inline T* Tensor::mutable_data(platform::Place place, bool use_pinned) {
+inline T* Tensor::mutable_data(platform::Place place, bool is_pinned) {
   static_assert(std::is_pod<T>::value, "T must be POD");
-  return reinterpret_cast<T*>(mutable_data(place, typeid(T), use_pinned));
+  return reinterpret_cast<T*>(mutable_data(place, typeid(T), is_pinned));
 }
 
 inline void* Tensor::mutable_data(platform::Place place, std::type_index type,
-                                  bool use_pinned) {
+                                  bool is_pinned) {
   if (holder_ != nullptr) {
     holder_->set_type(type);
   }
@@ -129,27 +129,27 @@ inline void* Tensor::mutable_data(platform::Place place, std::type_index type,
       holder_->size() < size + offset_) {
     if (platform::is_cpu_place(place)) {
       holder_.reset(new PlaceholderImpl<platform::CPUPlace>(
-          boost::get<platform::CPUPlace>(place), size, type, use_pinned));
+          boost::get<platform::CPUPlace>(place), size, type, is_pinned));
     } else if (platform::is_gpu_place(place)) {
 #ifndef PADDLE_WITH_CUDA
       PADDLE_THROW("'CUDAPlace' is not supported in CPU only device.");
     }
 #else
       holder_.reset(new PlaceholderImpl<platform::CUDAPlace>(
-          boost::get<platform::CUDAPlace>(place), size, type, use_pinned));
+          boost::get<platform::CUDAPlace>(place), size, type, is_pinned));
     }
 #endif
     offset_ = 0;
-    use_pinned_ = use_pinned;
+    is_pinned_ = is_pinned;
   }
   return reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(holder_->ptr()) +
                                  offset_);
 }
 
-inline void* Tensor::mutable_data(platform::Place place, bool use_pinned) {
+inline void* Tensor::mutable_data(platform::Place place, bool is_pinned) {
   PADDLE_ENFORCE(this->holder_ != nullptr,
                  "Cannot invoke mutable data if current hold nothing");
-  return mutable_data(place, holder_->type(), use_pinned);
+  return mutable_data(place, holder_->type(), is_pinned);
 }
 
 inline Tensor& Tensor::ShareDataWith(const Tensor& src) {
@@ -191,7 +191,7 @@ inline const DDim& Tensor::dims() const { return dims_; }
 
 inline int64_t Tensor::numel() const { return product(dims_); }
 
-inline bool Tensor::isPinned() const { return use_pinned_; }
+inline bool Tensor::isPinned() const { return is_pinned_; }
 
 inline Tensor ReshapeToMatrix(const Tensor& src, int num_col_dims) {
   Tensor res;

paddle/fluid/memory/detail/system_allocator.cc

@@ -123,8 +123,9 @@ void* CUDAPinnedAllocator::Alloc(size_t& index, size_t size) {
   if (size <= 0) return nullptr;
   void* p;
   // NOTE: here, we use GpuMaxAllocSize() as the maximum memory size
-  // of host fallback allocation. Allocates too much would reduce
+  // of host pinned allocation. Allocates too much would reduce
   // the amount of memory available to the underlying system for paging.
+  // Because the memory is in CPU side, other device can access it too.
 
   size_t usable = paddle::platform::GpuMaxAllocSize() - fallback_alloc_size_;
 
@@ -149,10 +150,10 @@ void CUDAPinnedAllocator::Free(void* p, size_t size, size_t index) {
   err = cudaFreeHost(p);
 
   // Purposefully allow cudaErrorCudartUnloading, because
-  // that is returned if you ever call cudaFree after the
+  // that is returned if you ever call cudaFreeHost after the
   // driver has already shutdown. This happens only if the
   // process is terminating, in which case we don't care if
-  // cudaFree succeeds.
+  // cudaFreeHost succeeds.
   if (err != cudaErrorCudartUnloading) {
     PADDLE_ENFORCE(err, "cudaFreeHost failed in GPUPinnedAllocator::Free.");
   }

paddle/fluid/memory/memory.cc

@@ -39,7 +39,7 @@ BuddyAllocator* GetCPUBuddyAllocator() {
 
 template <>
 void* Alloc<platform::CPUPlace>(platform::CPUPlace place, size_t size,
-                                bool use_pinned) {
+                                bool is_pinned) {
   VLOG(10) << "Allocate " << size << " bytes on " << platform::Place(place);
   void* p = GetCPUBuddyAllocator()->Alloc(size);
   VLOG(10) << "  pointer=" << p;
@@ -48,7 +48,7 @@ void* Alloc<platform::CPUPlace>(platform::CPUPlace place, size_t size,
 
 template <>
 void Free<platform::CPUPlace>(platform::CPUPlace place, void* p,
-                              bool use_pinned) {
+                              bool is_pinned) {
   VLOG(10) << "Free pointer=" << p << " on " << platform::Place(place);
   GetCPUBuddyAllocator()->Free(p);
 }
@@ -115,9 +115,9 @@ size_t Used<platform::CUDAPlace>(platform::CUDAPlace place) {
 
 template <>
 void* Alloc<platform::CUDAPlace>(platform::CUDAPlace place, size_t size,
-                                 bool use_pinned) {
+                                 bool is_pinned) {
   void* ptr;
-  if (use_pinned) {
+  if (is_pinned) {
     auto* buddy_allocator = GetCUDAPinnedBuddyAllocator(place.device);
     ptr = buddy_allocator->Alloc(size);
   } else {
@@ -143,8 +143,8 @@ void* Alloc<platform::CUDAPlace>(platform::CUDAPlace place, size_t size,
 
 template <>
 void Free<platform::CUDAPlace>(platform::CUDAPlace place, void* p,
-                               bool use_pinned) {
-  if (use_pinned) {
+                               bool is_pinned) {
+  if (is_pinned) {
     GetCUDAPinnedBuddyAllocator(place.device)->Free(p);
   } else {
     GetGPUBuddyAllocator(place.device)->Free(p);

paddle/fluid/memory/memory.h

@@ -33,7 +33,7 @@ namespace memory {
  *          address is valid or not.
  */
 template <typename Place>
-void* Alloc(Place place, size_t size, bool use_pinned = false);
+void* Alloc(Place place, size_t size, bool is_pinned = false);
 
 /**
  * \brief   Free memory block in one place.
@@ -43,7 +43,7 @@ void* Alloc(Place place, size_t size, bool use_pinned = false);
  *
  */
 template <typename Place>
-void Free(Place place, void* ptr, bool use_pinned = false);
+void Free(Place place, void* ptr, bool is_pinned = false);
 
 /**
  * \brief   Total size of used memory in one place.
@@ -74,15 +74,13 @@ class PODDeleter {
   static_assert(std::is_pod<T>::value, "T must be POD");
 
  public:
-  explicit PODDeleter(Place place, bool use_pinned = false)
-      : place_(place), use_pinned_(use_pinned) {}
-  void operator()(T* ptr) {
-    Free(place_, static_cast<void*>(ptr), use_pinned_);
-  }
+  explicit PODDeleter(Place place, bool is_pinned = false)
+      : place_(place), is_pinned_(is_pinned) {}
+  void operator()(T* ptr) { Free(place_, static_cast<void*>(ptr), is_pinned_); }
 
  private:
   Place place_;
-  bool use_pinned_;
+  bool is_pinned_;
 };
 
 /**