Merge remote-tracking branch 'upstream/develop' into factorization_machine_layer

paddle/framework/scope.cc

@@ -65,16 +65,12 @@ void Scope::DropKids() {
   kids_.clear();
 }
 
-std::once_flag feed_variable_flag;
-
 framework::Scope& GetGlobalScope() {
-  static std::unique_ptr<framework::Scope> g_scope{nullptr};
-  std::call_once(feed_variable_flag, [&]() {
-    g_scope.reset(new framework::Scope());
-    g_scope->Var("feed_value");
-    g_scope->Var("fetch_value");
-  });
-  return *(g_scope.get());
+  static framework::Scope* g_scope = nullptr;
+  if (g_scope == nullptr) {
+    g_scope = new framework::Scope();
+  }
+  return *g_scope;
 }
 
 }  // namespace framework

paddle/memory/memory.cc

@@ -14,11 +14,6 @@ limitations under the License. */
 
 #include "paddle/memory/memory.h"
 
-#include <algorithm>  // for transform
-#include <cstring>    // for memcpy
-#include <memory>     // for unique_ptr
-#include <mutex>      // for call_once
-
 #include "glog/logging.h"
 
 #include "paddle/memory/detail/buddy_allocator.h"
@@ -32,19 +27,14 @@ namespace memory {
 
 using BuddyAllocator = detail::BuddyAllocator;
 
-std::once_flag cpu_allocator_flag;
-std::once_flag gpu_allocator_flag;
-
 BuddyAllocator* GetCPUBuddyAllocator() {
-  static std::unique_ptr<BuddyAllocator> a{nullptr};
-
-  std::call_once(cpu_allocator_flag, [&]() {
-    a.reset(new BuddyAllocator(new detail::CPUAllocator,
-                               platform::CpuMinChunkSize(),
-                               platform::CpuMaxChunkSize()));
-  });
-
-  return a.get();
+  static detail::BuddyAllocator* a = nullptr;
+  if (a == nullptr) {
+    a = new detail::BuddyAllocator(new detail::CPUAllocator,
+                                   platform::CpuMinChunkSize(),
+                                   platform::CpuMaxChunkSize());
+  }
+  return a;
 }
 
 template <>
@@ -65,35 +55,24 @@ size_t Used<platform::CPUPlace>(platform::CPUPlace place) {
 #ifdef PADDLE_WITH_CUDA
 
 BuddyAllocator* GetGPUBuddyAllocator(int gpu_id) {
-  using BuddyAllocVec = std::vector<BuddyAllocator*>;
-  static std::unique_ptr<BuddyAllocVec, void (*)(BuddyAllocVec * p)> as{
-      new BuddyAllocVec, [](BuddyAllocVec* p) {
-        std::for_each(p->begin(), p->end(),
-                      [](BuddyAllocator* p) { delete p; });
-      }};
-
-  // GPU buddy allocators
-  auto& allocators = *as.get();
-
-  // GPU buddy allocator initialization
-  std::call_once(gpu_allocator_flag, [&]() {
+  static BuddyAllocator** as = NULL;
+  if (as == NULL) {
     int gpu_num = platform::GetCUDADeviceCount();
-    allocators.reserve(gpu_num);
+    as = new BuddyAllocator*[gpu_num];
     for (int gpu = 0; gpu < gpu_num; gpu++) {
       platform::SetDeviceId(gpu);
-      allocators.emplace_back(new BuddyAllocator(new detail::GPUAllocator,
-                                                 platform::GpuMinChunkSize(),
-                                                 platform::GpuMaxChunkSize()));
+      as[gpu] = new BuddyAllocator(new detail::GPUAllocator,
+                                   platform::GpuMinChunkSize(),
+                                   platform::GpuMaxChunkSize());
     }
     VLOG(3) << "\n\nNOTE: each GPU device use "
             << FLAGS_fraction_of_gpu_memory_to_use * 100 << "% of GPU memory.\n"
             << "You can set environment variable '"
             << platform::kEnvFractionGpuMemoryToUse
             << "' to change the fraction of GPU usage.\n\n";
-  });
-
+  }
   platform::SetDeviceId(gpu_id);
-  return allocators[gpu_id];
+  return as[gpu_id];
 }
 
 template <>