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]