Update CMakeLists.txt and expected.h, remove unused files, and improve thread safety in block_pool.cpp

Author: mutouyun

CMakeLists.txt

@@ -11,7 +11,7 @@ set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 set(CMAKE_CXX_STANDARD 17)
 
 if (MSVC)
-  set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /fsanitize=address /Zi")
+  set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /Zi")
   set(CompilerFlags
       CMAKE_CXX_FLAGS
       CMAKE_CXX_FLAGS_DEBUG

benchmark/benchmark_new.cpp

@@ -322,7 +322,7 @@ R or_else(E &&exp, F &&f) {
  */
 template <typename T, typename E>
 class expected : public detail_expected::storage<typename std::remove_cv<T>::type, E> {
- public:
+public:
   using value_type = typename std::remove_cv<T>::type;
   using error_type = E;
 

include/libimp/expected.h

@@ -8,8 +8,6 @@
 
 #include <cstddef>
 
-#include "libimp/aligned.h"
-
 #define LIBPMR                pmr
 #define LIBPMR_NAMESPACE_BEG_ namespace LIBPMR {
 #define LIBPMR_NAMESPACE_END_ }
@@ -20,7 +18,6 @@ LIBPMR_NAMESPACE_BEG_
 
 enum : std::size_t {
   central_cache_default_size = 1024 * 1024, ///< 1MB
-  regular_head_size          = ::LIBIMP::round_up(sizeof(std::size_t), alignof(std::max_align_t)),
 };
 
 LIBPMR_NAMESPACE_END_

include/libpmr/def.h

@@ -7,7 +7,6 @@
 #pragma once
 
 #include <cstddef>
-#include <unordered_map>
 #include <algorithm>
 
 #include "libimp/aligned.h"
@@ -22,6 +21,18 @@
 
 LIBPMR_NAMESPACE_BEG_
 
+/// \brief Defines the memory block collector interface.
+class LIBIMP_EXPORT block_collector {
+public:
+  virtual ~block_collector() noexcept = default;
+  virtual void deallocate(void *p) noexcept = 0;
+};
+
+using get_block_collector_t = block_collector *(*)() noexcept;
+
+static constexpr std::size_t regular_head_size
+    = ::LIBIMP::round_up(sizeof(get_block_collector_t), alignof(std::max_align_t));
+
 /// \brief Select the incremental level based on the size.
 constexpr inline std::size_t regular_level(std::size_t s) noexcept {
   return (s <= 128  ) ? 0 :
@@ -32,52 +43,25 @@ constexpr inline std::size_t regular_level(std::size_t s) noexcept {
 
 /// \brief Calculates the appropriate memory block size based on the increment level and size.
 constexpr inline std::size_t regular_sizeof_impl(std::size_t l, std::size_t s) noexcept {
-  return (l == 0) ? std::max<std::size_t>(::LIBIMP::round_up<std::size_t>(s, 8), regular_head_size) :
+  return (l == 0) ? ::LIBIMP::round_up<std::size_t>(s, regular_head_size) :
          (l == 1) ? ::LIBIMP::round_up<std::size_t>(s, 128 ) :
          (l == 2) ? ::LIBIMP::round_up<std::size_t>(s, 1024) :
          (l == 3) ? ::LIBIMP::round_up<std::size_t>(s, 8192) : (std::numeric_limits<std::size_t>::max)();
 }
 
 /// \brief Calculates the appropriate memory block size based on the size.
-constexpr inline std::size_t regular_sizeof(std::size_t s) noexcept {
+constexpr inline std::size_t regular_sizeof_impl(std::size_t s) noexcept {
   return regular_sizeof_impl(regular_level(s), s);
 }
 
 /// \brief Calculates the appropriate memory block size based on the specific type.
 template <typename T>
 constexpr inline std::size_t regular_sizeof() noexcept {
-  return regular_sizeof(regular_head_size + sizeof(T));
+  return regular_sizeof_impl(regular_head_size + sizeof(T));
 }
 
-/// \brief Defines the memory block collector interface.
-class LIBIMP_EXPORT block_collector {
- public:
-  virtual ~block_collector() noexcept = default;
-  virtual void deallocate(void *p) noexcept = 0;
-};
-
-/// \brief Gets all block pools of the thread cache.
-LIBIMP_EXPORT auto get_thread_block_pool_map() noexcept
-  -> std::unordered_map<std::size_t, block_collector *> &;
-
 /// \brief Defines block pool memory resource based on block pool.
 template <std::size_t BlockSize, std::size_t BlockPoolExpansion>
-class block_pool_resource;
-
-/// \brief Memory block collector of unknown size.
-/// \note This memory resource is only used to temporarily collect memory blocks 
-///       that cannot find a suitable block pool memory resource.
-template <>
-class block_pool_resource<0, 0> : public block_pool<0, 0>
-                                , public block_collector {
-public:
-  void deallocate(void *p) noexcept override {
-    block_pool<0, 0>::deallocate(p);
-  }
-};
-
-/// \brief A block pool memory resource for a block of memory of a specific size.
-template <std::size_t BlockSize, std::size_t BlockPoolExpansion>
 class block_pool_resource : public block_pool<BlockSize, BlockPoolExpansion>
                           , public block_collector {
 
@@ -88,99 +72,59 @@ class block_pool_resource : public block_pool<BlockSize, BlockPoolExpansion>
   }
 
 public:
-  static block_pool_resource *get() noexcept;
+  static block_collector *get() noexcept {
+    thread_local block_pool_resource instance;
+    return &instance;
+  }
 
   using base_t::base_t;
 
   void *allocate(std::size_t /*bytes*/, std::size_t /*alignment*/ = alignof(std::max_align_t)) noexcept {
     void *p = base_t::allocate();
-    p = ::LIBIMP::construct<std::size_t>(p, BlockSize);
-    return reinterpret_cast<::LIBIMP::byte *>(p) + regular_head_size;
+    *static_cast<get_block_collector_t *>(p) = get;
+    return static_cast<::LIBIMP::byte *>(p) + regular_head_size;
   }
 
   void deallocate(void *p, std::size_t /*bytes*/, std::size_t /*alignment*/ = alignof(std::max_align_t)) noexcept {
-    p = reinterpret_cast<::LIBIMP::byte *>(p) - regular_head_size;
-    auto r_size = *static_cast<std::size_t *>(p);
-    if (r_size <= BlockSize) {
+    p = static_cast<::LIBIMP::byte *>(p) - regular_head_size;
+    auto g = *static_cast<get_block_collector_t *>(p);
+    if (g == get) {
       base_t::deallocate(p);
       return;
     }
-    // When the actual size exceeds the current memory block size, 
-    // try to find a suitable pool among all memory block pools for this thread.
-    auto &map = get_thread_block_pool_map();
-    auto it = map.find(r_size);
-    if ((it == map.end()) || (it->second == nullptr)) {
-      block_pool_resource<0, 0> *bp = nullptr;
-      LIBIMP_TRY {
-        // If the corresponding memory resource cannot be found, 
-        // create a temporary general-purpose block pool to deallocate memory.
-        it = map.emplace(r_size, bp = new block_pool_resource<0, 0>).first;
-      } LIBIMP_CATCH(...) {
-        // If the memory resource cannot be created, 
-        // store the pointer directly to avoid leakage.
-        delete bp;
-        base_t::deallocate(p);
-        return;
-      }
-    }
-    it->second->deallocate(p);
+    g()->deallocate(p);
   }
 };
 
-template <std::size_t BlockSize, std::size_t BlockPoolExpansion>
-auto block_pool_resource<BlockSize, BlockPoolExpansion>::get() noexcept
-  -> block_pool_resource<BlockSize, BlockPoolExpansion> * {
-  thread_local block_pool_resource *pi = nullptr;
-  if (pi != nullptr) {
-    return pi;
-  }
-  // Create a new block pool resource for this thread.
-  auto &map = get_thread_block_pool_map();
-  auto it = map.find(BlockSize);
-  if ((it != map.end()) && (it->second != nullptr)) {
-    // If there are existing block pool resources in the thread cache, 
-    // a new block pool resource is constructed based on it and the cache is updated.
-    auto *bp = static_cast <block_pool<0, 0> *>(
-               dynamic_cast<block_pool_resource<0, 0> *>(it->second));
-    if (bp == nullptr) {
-      return nullptr;
-    }
-    thread_local block_pool_resource instance(std::move(*bp));
-    delete static_cast<block_pool_resource<0, 0> *>(bp);
-    it->second = pi = &instance;
-    return pi;
-  } else {
-    // If there are no existing block pool resources in the thread cache, 
-    // the thread local storage instance is constructed and the pointer is cached.
-    thread_local block_pool_resource instance;
-    LIBIMP_TRY {
-      map.emplace(BlockSize, pi = &instance);
-      return pi;
-    } LIBIMP_CATCH(...) {
-      return nullptr;
-    }
-  }
-}
+/// \brief Different increment levels match different chunk sizes.
+///        512 means that 512 consecutive memory blocks are allocated at a time, and the block size is N.
+template <std::size_t L>
+constexpr static std::size_t block_pool_expansion = 0;
+
+template <> constexpr static std::size_t block_pool_expansion<0> = 512;
+template <> constexpr static std::size_t block_pool_expansion<1> = 256;
+template <> constexpr static std::size_t block_pool_expansion<2> = 128;
+template <> constexpr static std::size_t block_pool_expansion<3> = 64;
 
-/// \brief Match the appropriate memory block resources 
-///        according to the size of the specification.
+/// \brief Match the appropriate memory block resources according to the size of the specification.
 template <std::size_t N, std::size_t L = regular_level(N)>
-class regular_resource : public new_delete_resource {};
+struct regular_resource {
+  static auto *get() noexcept {
+    using block_poll_resource_t = block_pool_resource<N, block_pool_expansion<L>>;
+    return dynamic_cast<block_poll_resource_t *>(block_poll_resource_t::get());
+  }
+};
 
-/// \brief Different increment levels match different chunk sizes.
-///        512 means that 512 consecutive memory blocks are allocated at a time, and the block size is N.
-template <std::size_t N> class regular_resource<N, 0> : public block_pool_resource<N, 512> {};
-template <std::size_t N> class regular_resource<N, 1> : public block_pool_resource<N, 256> {};
-template <std::size_t N> class regular_resource<N, 2> : public block_pool_resource<N, 128> {};
-template <std::size_t N> class regular_resource<N, 3> : public block_pool_resource<N, 64 > {};
+template <std::size_t N>
+struct regular_resource<N, 4> : new_delete_resource {};
 
 /// \brief Creates an object based on the specified type and parameters with block pool resource.
 /// \note This function is thread-safe.
 template <typename T, typename... A>
 T *new$(A &&... args) noexcept {
-  auto *mem_res = regular_resource<regular_sizeof<T>()>::get();
-  if (mem_res == nullptr) return nullptr;
-  return ::LIBIMP::construct<T>(mem_res->allocate(sizeof(T), alignof(T)), std::forward<A>(args)...);
+  auto *res = regular_resource<regular_sizeof<T>()>::get();
+  if (res == nullptr) return nullptr;
+  return ::LIBIMP::construct<T>(res->allocate(sizeof(T), alignof(T)), std::forward<A>(args)...);
 }
 
 /// \brief Destroys object previously allocated by the `new$` and releases obtained memory area.
@@ -190,13 +134,13 @@ template <typename T>
 void delete$(T *p) noexcept {
   if (p == nullptr) return;
   ::LIBIMP::destroy(p);
-  auto *mem_res = regular_resource<regular_sizeof<T>()>::get();
-  if (mem_res == nullptr) return;
+  auto *res = regular_resource<regular_sizeof<T>()>::get();
+  if (res == nullptr) return;
 #if defined(LIBIMP_CC_MSVC_2015)
   // `alignof` of vs2015 requires that type must be able to be instantiated.
-  mem_res->deallocate(p, sizeof(T));
+  res->deallocate(p, sizeof(T));
 #else
-  mem_res->deallocate(p, sizeof(T), alignof(T));
+  res->deallocate(p, sizeof(T), alignof(T));
 #endif
 }
 

include/libpmr/new.h

@@ -1,13 +1,41 @@
 
+#include <mutex>
+
+#include "libimp/detect_plat.h"
+
 #include "libpmr/block_pool.h"
 #include "libpmr/monotonic_buffer_resource.h"
 
 LIBPMR_NAMESPACE_BEG_
 
+class thread_safe_resource : public monotonic_buffer_resource {
+public:
+  thread_safe_resource(::LIBIMP::span<::LIBIMP::byte> buffer) noexcept
+      : monotonic_buffer_resource(buffer) {}
+
+  ~thread_safe_resource() noexcept {
+    LIBIMP_UNUSED std::lock_guard<std::mutex> lock(mutex_);
+    monotonic_buffer_resource::release();
+  }
+
+  void *allocate(std::size_t bytes, std::size_t alignment) noexcept {
+    LIBIMP_UNUSED std::lock_guard<std::mutex> lock(mutex_);
+    return monotonic_buffer_resource::allocate(bytes, alignment);
+  }
+
+  void deallocate(void *p, std::size_t bytes, std::size_t alignment) noexcept {
+    LIBIMP_UNUSED std::lock_guard<std::mutex> lock(mutex_);
+    monotonic_buffer_resource::deallocate(p, bytes, alignment);
+  }
+
+private:
+  std::mutex mutex_;
+};
+
 allocator &central_cache_allocator() noexcept {
-  static std::array<::LIBIMP::byte, central_cache_default_size> buffer;
-  static monotonic_buffer_resource mr(buffer);
-  static allocator a(&mr);
+  static std::array<::LIBIMP::byte, central_cache_default_size> buf;
+  static thread_safe_resource res(buf);
+  static allocator a(&res);
   return a;
 }
 

src/libpmr/block_pool.cpp

@@ -3,6 +3,7 @@
 #include <array>
 #include <cstring>
 #include <cstddef>
+#include <thread>
 
 #include "gtest/gtest.h"
 
@@ -114,3 +115,32 @@ TEST(pmr_new, delete$null) {
   pmr::delete$(p);
   SUCCEED();
 }
+
+TEST(pmr_new, multi_thread) {
+  std::array<std::thread, 16> threads;
+  for (auto &t : threads) {
+    t = std::thread([] {
+      for (int i = 0; i < 10000; ++i) {
+        auto p = pmr::new$<int>();
+        *p = i;
+        pmr::delete$(p);
+      }
+      std::array<void *, 10000> pts;
+      for (int i = 0; i < 10000; ++i) {
+        auto p = pmr::new$<std::array<char, 10>>();
+        pts[i] = p;
+        std::memset(p, i, sizeof(std::array<char, 10>));
+      }
+      for (int i = 0; i < 10000; ++i) {
+        std::array<char, 10> tmp;
+        std::memset(&tmp, i, sizeof(std::array<char, 10>));
+        ASSERT_EQ(std::memcmp(pts[i], &tmp, sizeof(std::array<char, 10>)), 0);
+        pmr::delete$(static_cast<std::array<char, 10> *>(pts[i]));
+      }
+    });
+  }
+  for (auto &t : threads) {
+    t.join();
+  }
+  SUCCEED();
+}