This is an automated email from the ASF dual-hosted git repository.

chenBright pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/brpc.git


The following commit(s) were added to refs/heads/master by this push:
     new 81c5e5c5e Fix object pool block size limits under ASan (#3737)
81c5e5c5e is described below

commit 81c5e5c5efefa7597b197aed333ae3ad414689e1
Author: Bright Chen <[email protected]>
AuthorDate: Wed Nov 11 22:33:48 2026 +0800

    Fix object pool block size limits under ASan (#3737)
---
 src/butil/object_pool.h       | 14 ++++-----
 src/butil/object_pool_inl.h   | 43 +++++++++++++--------------
 test/object_pool_unittest.cpp | 69 +++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 96 insertions(+), 30 deletions(-)

diff --git a/src/butil/object_pool.h b/src/butil/object_pool.h
index f0a66cc32..fd6808342 100644
--- a/src/butil/object_pool.h
+++ b/src/butil/object_pool.h
@@ -38,9 +38,11 @@ namespace butil {
 //     };
 //   }
 
-// Memory is allocated in blocks, memory size of a block will not exceed:
-//   min(ObjectPoolBlockMaxSize<T>::value,
-//       ObjectPoolBlockMaxItem<T>::value * sizeof(T))
+// Memory is allocated in blocks. Object slots in each block are limited by
+// ObjectPoolBlockMaxSize<T>::value bytes and ObjectPoolBlockMaxItem<T>::value
+// objects. Slot size includes alignment padding, such as that required by 
ASan.
+// With a positive item limit, each block holds at least one object even if its
+// slot exceeds the byte limit. Block metadata and allocator overhead are 
excluded.
 template <typename T> struct ObjectPoolBlockMaxSize {
     static const size_t value = 64 * 1024; // bytes
 };
@@ -49,10 +51,8 @@ template <typename T> struct ObjectPoolBlockMaxItem {
 };
 
 // Free objects of each thread are grouped into a chunk before they are merged
-// to the global list. Memory size of objects in one free chunk will not 
exceed:
-//   min(ObjectPoolFreeChunkMaxItem<T>::value() * sizeof(T),
-//       ObjectPoolBlockMaxSize<T>::value,
-//       ObjectPoolBlockMaxItem<T>::value * sizeof(T))
+// to the global list. The object count is at most
+// ObjectPoolFreeChunkMaxItem<T>::value(), capped by the number of slots in a 
block.
 template <typename T> struct ObjectPoolFreeChunkMaxItem {
     static size_t value() { return 256; }
 };
diff --git a/src/butil/object_pool_inl.h b/src/butil/object_pool_inl.h
index 97a63d2c2..c807b6816 100644
--- a/src/butil/object_pool_inl.h
+++ b/src/butil/object_pool_inl.h
@@ -79,11 +79,20 @@ static const size_t OP_INITIAL_FREE_LIST_SIZE = 1024;
 
 template <typename T>
 class ObjectPoolBlockItemNum {
-    static const size_t N1 = ObjectPoolBlockMaxSize<T>::value / sizeof(T);
+public:
+#ifdef BUTIL_USE_ASAN
+    // ASan manual poisoning requires slots to start at 8-byte boundaries.
+    typedef AlignedMemory<sizeof(T), __alignof__(T) < 8 ? 8 : __alignof__(T)> 
BlockItem;
+#else
+    typedef AlignedMemory<sizeof(T), __alignof__(T)> BlockItem;
+#endif
+
+private:
+    static const size_t N1 = ObjectPoolBlockMaxSize<T>::value / 
sizeof(BlockItem);
     static const size_t N2 = (N1 < 1 ? 1 : N1);
 public:
-    static const size_t value = (N2 > ObjectPoolBlockMaxItem<T>::value ?
-                                 ObjectPoolBlockMaxItem<T>::value : N2);
+    static const size_t value =
+        N2 > ObjectPoolBlockMaxItem<T>::value ? 
ObjectPoolBlockMaxItem<T>::value : N2;
 };
 
 template <typename T>
@@ -117,20 +126,13 @@ public:
 
     // Free objects are batched in a FreeChunk before they're added to
     // global list(_free_chunks).
-    typedef ObjectPoolFreeChunk<T, FREE_CHUNK_NITEM>    FreeChunk;
+    typedef ObjectPoolFreeChunk<T, FREE_CHUNK_NITEM> FreeChunk;
     struct GlobalFreeChunk {
         int64_t push_us;
         size_t nfree;
         T* ptrs[0];
     };
-#ifdef BUTIL_USE_ASAN
-    // According to 
https://github.com/google/sanitizers/wiki/AddressSanitizerManualPoisoning ,
-    // The allocated chunks should start with 8-aligned addresses,
-    // so that AlignedMemory starts with at least 8-aligned addresses.
-    typedef AlignedMemory<sizeof(T), __alignof__(T) < 8 ? 8 : __alignof__(T)> 
BlockItem;
-#else
-    typedef AlignedMemory<sizeof(T), __alignof__(T)> BlockItem;
-#endif
+    typedef typename ObjectPoolBlockItemNum<T>::BlockItem BlockItem;
 
     // When a thread needs memory, it allocates a Block. To improve locality,
     // items in the Block are only used by the thread.
@@ -459,10 +461,7 @@ private:
 
     // Create a Block and append it to right-most BlockGroup.
     static Block* add_block(size_t* index) {
-        Block* const new_block = new(std::nothrow) Block;
-        if (nullptr == new_block) {
-            return nullptr;
-        }
+        auto const new_block = new Block;
         size_t ngroup;
         do {
             ngroup = _ngroup.load(butil::memory_order_acquire);
@@ -497,13 +496,11 @@ private:
             return true;
         }
         if (ngroup < OP_MAX_BLOCK_NGROUP) {
-            bg = new(std::nothrow) BlockGroup;
-            if (nullptr != bg) {
-                // Release fence is paired with consume fence in add_block()
-                // to avoid un-constructed bg to be seen by other threads.
-                _block_groups[ngroup].store(bg, butil::memory_order_release);
-                _ngroup.store(ngroup + 1, butil::memory_order_release);
-            }
+            bg = new BlockGroup;
+            // Release fence is paired with consume fence in add_block()
+            // to avoid un-constructed bg to be seen by other threads.
+            _block_groups[ngroup].store(bg, butil::memory_order_release);
+            _ngroup.store(ngroup + 1, butil::memory_order_release);
         }
         return bg != nullptr;
     }
diff --git a/test/object_pool_unittest.cpp b/test/object_pool_unittest.cpp
index 367bb8a0e..628203551 100644
--- a/test/object_pool_unittest.cpp
+++ b/test/object_pool_unittest.cpp
@@ -29,6 +29,11 @@ namespace {
 struct MyObject {};
 struct FreeChunkCountObject {};
 
+template <size_t Size, size_t MaxSize, size_t MaxItem = 1024>
+struct BlockSizeLimitedObject {
+    char data[Size];
+};
+
 int nfoo_dtor = 0;
 struct Foo {
     Foo() {
@@ -42,6 +47,16 @@ struct Foo {
 }
 
 namespace butil {
+template <size_t Size, size_t MaxSize, size_t MaxItem>
+struct ObjectPoolBlockMaxSize<BlockSizeLimitedObject<Size, MaxSize, MaxItem> > 
{
+    static const size_t value = MaxSize;
+};
+
+template <size_t Size, size_t MaxSize, size_t MaxItem>
+struct ObjectPoolBlockMaxItem<BlockSizeLimitedObject<Size, MaxSize, MaxItem> > 
{
+    static const size_t value = MaxItem;
+};
+
 template <> struct ObjectPoolBlockMaxSize<MyObject> {
     static const size_t value = 128;
 };
@@ -111,6 +126,60 @@ TEST_F(ObjectPoolTest, change_config) {
     std::cout << describe_objects<MyObject>() << std::endl;
 }
 
+template <typename T>
+void check_block_capacity(size_t expected_capacity) {
+    typedef typename ObjectPool<T>::Block Block;
+    typedef typename ObjectPool<T>::BlockItem BlockItem;
+    const size_t max_size = ObjectPoolBlockMaxSize<T>::value;
+    if (max_size >= sizeof(BlockItem)) {
+        EXPECT_LE(sizeof(Block::items), max_size);
+    } else {
+        EXPECT_EQ(sizeof(BlockItem), sizeof(Block::items));
+    }
+
+    clear_objects<T>();
+    EXPECT_EQ(expected_capacity, describe_objects<T>().block_item_num);
+    std::vector<T*> objects;
+    for (size_t i = 0; i < expected_capacity; ++i) {
+        T* obj = get_object<T>();
+        ASSERT_TRUE(obj);
+        obj->data[0] = 'x';
+        objects.push_back(obj);
+    }
+    EXPECT_EQ(1u, describe_objects<T>().block_num);
+    T* next = get_object<T>();
+    ASSERT_TRUE(next);
+    EXPECT_EQ(2u, describe_objects<T>().block_num);
+    EXPECT_EQ(0, return_object(next));
+    EXPECT_EQ(next, get_object<T>());
+    EXPECT_EQ(0, return_object(next));
+    for (T* obj : objects) {
+        EXPECT_EQ('x', obj->data[0]);
+        EXPECT_EQ(0, return_object(obj));
+    }
+    clear_objects<T>();
+}
+
+TEST_F(ObjectPoolTest, block_size_limit_includes_slot_padding) {
+#ifdef BUTIL_USE_ASAN
+    check_block_capacity<BlockSizeLimitedObject<1, 1024> >(128);
+    check_block_capacity<BlockSizeLimitedObject<9, 1024> >(64);
+#else
+    check_block_capacity<BlockSizeLimitedObject<1, 1024> >(1024);
+    check_block_capacity<BlockSizeLimitedObject<9, 1024> >(113);
+#endif
+}
+
+TEST_F(ObjectPoolTest, block_size_limit_keeps_at_least_one_object) {
+    check_block_capacity<BlockSizeLimitedObject<1, 1> >(1);
+    check_block_capacity<BlockSizeLimitedObject<9, 8> >(1);
+    check_block_capacity<BlockSizeLimitedObject<1, 0> >(1);
+}
+
+TEST_F(ObjectPoolTest, block_size_limit_preserves_item_limit) {
+    check_block_capacity<BlockSizeLimitedObject<1, 1024, 3> >(3);
+}
+
 struct NonDefaultCtorObject {
     explicit NonDefaultCtorObject(int value) : _value(value) {}
     NonDefaultCtorObject(int value, int dummy) : _value(value + dummy) {}


---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]

Reply via email to