ENH: Replace pool allocator to buddy allocator in Paddle

paddle/function/ConvOp.h

@@ -131,7 +131,7 @@ class ConvFunctionBase : public FunctionBase {
 
   template <DeviceType Device>
   void resizeBuffer(size_t newSize) {
-    if (!memory_ || newSize * sizeof(real) > memory_->getAllocSize()) {
+    if (!memory_ || newSize * sizeof(real) > memory_->getSize()) {
       if (Device == DEVICE_TYPE_CPU) {
         memory_ = std::make_shared<CpuMemoryHandle>(newSize * sizeof(real));
       } else {

paddle/gserver/layers/ConvBaseProjection.cpp

@@ -13,6 +13,7 @@ See the License for the specific language governing permissions and
 limitations under the License. */
 
 #include "ConvBaseProjection.h"
+#include "paddle/math/MemoryHandle.h"
 #include "paddle/utils/Stat.h"
 
 namespace paddle {
@@ -179,7 +180,7 @@ void *ConvBaseProjection::getSpaceBytes(size_t size) {
 
   int devId = hl_get_device();
   MemoryHandle **localMem = &(convMem[devId]);
-  if (NULL == *localMem || size > (*localMem)->getAllocSize()) {
+  if (NULL == *localMem || size > (*localMem)->getSize()) {
     *localMem = new GpuMemoryHandle(size);
   }
   return (*localMem)->getBuf();

paddle/math/CMakeLists.txt

@@ -28,7 +28,7 @@ else()
     cuda_add_library(paddle_math ${MATH_SOURCES})
 endif()
 
-
+target_link_libraries(paddle_math place paddle_memory)
 
 add_style_check_target(paddle_math ${MATH_SOURCES})
 add_style_check_target(paddle_math ${MATH_HEADERS})

paddle/math/Matrix.cpp

@@ -251,7 +251,7 @@ void GpuMatrix::resetOne() {
 void GpuMatrix::resize(size_t newHeight, size_t newWidth) {
   size_t newSize = newHeight * newWidth;
   if (NULL == memoryHandle_.get() ||
-      newSize * sizeof(real) > memoryHandle_->getAllocSize()) {
+      newSize * sizeof(real) > memoryHandle_->getSize()) {
     memoryHandle_ = std::make_shared<GpuMemoryHandle>(newSize * sizeof(real));
     data_ = reinterpret_cast<real*>(memoryHandle_->getBuf());
   }
@@ -1638,7 +1638,7 @@ MatrixPtr CpuMatrix::clone(size_t height, size_t width, bool useGpu) {
 void CpuMatrix::resize(size_t newHeight, size_t newWidth) {
   size_t newSize = newHeight * newWidth;
   if (NULL == memoryHandle_.get() ||
-      newSize * sizeof(real) > memoryHandle_->getAllocSize()) {
+      newSize * sizeof(real) > memoryHandle_->getSize()) {
     memoryHandle_ = std::make_shared<CpuMemoryHandle>(newSize * sizeof(real));
     data_ = reinterpret_cast<real*>(memoryHandle_->getBuf());
   }

paddle/math/MemoryHandle.cpp

@@ -13,44 +13,46 @@ See the License for the specific language governing permissions and
 limitations under the License. */
 
 #include "MemoryHandle.h"
+
+#include "glog/logging.h"
+
 #include <cmath>
-#include "Storage.h"
+
+#include "paddle/memory/memory.h"
+#include "paddle/platform/place.h"
 
 namespace paddle {
 
 /**
  * Calculate the actual allocation size according to the required size.
  */
-MemoryHandle::MemoryHandle(size_t size) : size_(size), buf_(nullptr) {
-  if (size_ <= 256) {
-    // Memory allocation in cuda is always aligned to at least 256 bytes.
-    // In many cases it is 512 bytes.
-    allocSize_ = 256;
-  } else if (size_ <= 512) {
-    allocSize_ = 512;
-  } else if (size_ <= (1 << 16)) {
-    // Allocate multiple of 1024 bytes.
-    allocSize_ = (size + 1023) & ~(1023);
-  } else {
-    allocSize_ = size_;
-  }
-}
+MemoryHandle::MemoryHandle(size_t size) : size_(size), buf_(nullptr) {}
+
+#ifndef PADDLE_ONLY_CPU
 
 GpuMemoryHandle::GpuMemoryHandle(size_t size) : MemoryHandle(size) {
   CHECK(size != 0) << " allocate 0 bytes";
-  deviceId_ = hl_get_device();
-  allocator_ = StorageEngine::singleton()->getGpuAllocator(deviceId_);
-  buf_ = allocator_->alloc(allocSize_);
+  deviceId_ = paddle::platform::GetCurrentDeviceId();
+  paddle::platform::GPUPlace gpu_place(deviceId_);
+  buf_ = paddle::memory::Alloc(gpu_place, size);
+}
+
+GpuMemoryHandle::~GpuMemoryHandle() {
+  paddle::platform::GPUPlace gpu_place(deviceId_);
+  paddle::memory::Free(gpu_place, buf_);
 }
 
-GpuMemoryHandle::~GpuMemoryHandle() { allocator_->free(buf_, allocSize_); }
+#endif  // PADDLE_ONLY_CPU
 
 CpuMemoryHandle::CpuMemoryHandle(size_t size) : MemoryHandle(size) {
   CHECK(size != 0) << " allocate 0 bytes";
-  allocator_ = StorageEngine::singleton()->getCpuAllocator();
-  buf_ = allocator_->alloc(allocSize_);
+  paddle::platform::GPUPlace cpu_place;
+  buf_ = paddle::memory::Alloc(cpu_place, size);
 }
 
-CpuMemoryHandle::~CpuMemoryHandle() { allocator_->free(buf_, allocSize_); }
+CpuMemoryHandle::~CpuMemoryHandle() {
+  paddle::platform::CPUPlace cpu_place;
+  paddle::memory::Free(cpu_place, buf_);
+}
 
 }  // namespace paddle

paddle/math/MemoryHandle.h

@@ -15,7 +15,6 @@ limitations under the License. */
 #pragma once
 
 #include <memory>
-#include "PoolAllocator.h"
 
 namespace paddle {
 
@@ -27,13 +26,10 @@ class MemoryHandle {
 public:
   void* getBuf() const { return buf_; }
   size_t getSize() const { return size_; }
-  size_t getAllocSize() const { return allocSize_; }
 
 protected:
-  PoolAllocator* allocator_;
-  size_t size_;       // the requested size
-  size_t allocSize_;  // the allocated size
-  int deviceId_;      // the device id of memory if gpu memory
+  size_t size_;   // the requested size
+  int deviceId_;  // the device id of memory if gpu memory
   void* buf_;
 };