Extend PoolInterface to heap pools

src/lib/dnssd/minimal_mdns/Server.h

@@ -228,7 +228,8 @@ class ServerBase
 
 // The PoolImpl impl is used as a base class because its destructor must be called after ServerBase's destructor.
 template <size_t kCount>
-class Server : private chip::PoolImpl<ServerBase::EndpointInfo, kCount, ServerBase::EndpointInfoPoolType::Interface>,
+class Server : private chip::PoolImpl<ServerBase::EndpointInfo, kCount, chip::ObjectPoolMem::kStatic,
+ ServerBase::EndpointInfoPoolType::Interface>,
  public ServerBase
 {
 public:

src/lib/dnssd/minimal_mdns/tests/CheckOnlyServer.h

@@ -71,7 +71,8 @@ void MakePrintableName(char (&location)[N], FullQName name)
 
 } // namespace
 
-class CheckOnlyServer : private chip::PoolImpl<ServerBase::EndpointInfo, 0, ServerBase::EndpointInfoPoolType::Interface>,
+class CheckOnlyServer : private chip::PoolImpl<ServerBase::EndpointInfo, 0, chip::ObjectPoolMem::kStatic,
+ ServerBase::EndpointInfoPoolType::Interface>,
  public ServerBase,
  public ParserDelegate,
  public TxtRecordDelegate

src/lib/support/Pool.h

@@ -336,33 +336,28 @@ class HeapObjectPool : public internal::Statistics, public internal::PoolCommon<
 
 #endif // CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
 
-#if CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
-template <typename T, unsigned int N>
-using ObjectPool = HeapObjectPool<T>;
-#else // CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
-template <typename T, unsigned int N>
-using ObjectPool = BitMapObjectPool<T, N>;
-#endif // CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
-
 enum class ObjectPoolMem
 {
  kStatic,
 #if CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
- kDynamic
+ kDynamic,
+ kDefault = kDynamic
+#else // CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
+ kDefault = kStatic
 #endif // CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
 };
 
-template <typename T, size_t N, ObjectPoolMem P>
-class MemTypeObjectPool;
+template <typename T, size_t N, ObjectPoolMem P = ObjectPoolMem::kDefault>
+class ObjectPool;
 
 template <typename T, size_t N>
-class MemTypeObjectPool<T, N, ObjectPoolMem::kStatic> : public BitMapObjectPool<T, N>
+class ObjectPool<T, N, ObjectPoolMem::kStatic> : public BitMapObjectPool<T, N>
 {
 };
 
 #if CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
 template <typename T, size_t N>
-class MemTypeObjectPool<T, N, ObjectPoolMem::kDynamic> : public HeapObjectPool<T>
+class ObjectPool<T, N, ObjectPoolMem::kDynamic> : public HeapObjectPool<T>
 {
 };
 #endif // CHIP_SYSTEM_CONFIG_POOL_USE_HEAP

src/lib/support/PoolWrapper.h

@@ -53,11 +53,11 @@ class PoolInterface
  virtual Loop ForEachActiveObjectInner(void * context, Lambda lambda) = 0;
 };
 
-template <class T, size_t N, typename Interface>
+template <class T, size_t N, ObjectPoolMem M, typename Interface>
 class PoolProxy;
 
-template <class T, size_t N, typename U, typename... ConstructorArguments>
-class PoolProxy<T, N, std::tuple<U, ConstructorArguments...>> : public PoolInterface<U, ConstructorArguments...>
+template <class T, size_t N, ObjectPoolMem M, typename U, typename... ConstructorArguments>
+class PoolProxy<T, N, M, std::tuple<U, ConstructorArguments...>> : public PoolInterface<U, ConstructorArguments...>
 {
 public:
  static_assert(std::is_base_of<U, T>::value, "Interface type is not derived from Pool type");
@@ -83,7 +83,7 @@ class PoolProxy<T, N, std::tuple<U, ConstructorArguments...>> : public PoolInter
  return Impl().ForEachActiveObject([&](T * target) { return lambda(context, static_cast<U *>(target)); });
  }
 
- virtual BitMapObjectPool<T, N> & Impl() = 0;
+ virtual ObjectPool<T, N, M> & Impl() = 0;
 };
 
 /*
@@ -92,23 +92,24 @@ class PoolProxy<T, N, std::tuple<U, ConstructorArguments...>> : public PoolInter
  *
  * @tparam T a subclass of element to be allocated.
  * @tparam N a positive integer max number of elements the pool provides.
+ * @tparam M an ObjectPoolMem constant selecting static vs heap allocation.
  * @tparam Interfaces a list of parameters which defines PoolInterface's. each interface is defined by a
  * std::tuple<U, ConstructorArguments...>. The PoolImpl is derived from every
  * PoolInterface<U, ConstructorArguments...>, the PoolImpl can be converted to the interface type
  * and passed around
  */
-template <class T, size_t N, typename... Interfaces>
-class PoolImpl : public PoolProxy<T, N, Interfaces>...
+template <class T, size_t N, ObjectPoolMem M, typename... Interfaces>
+class PoolImpl : public PoolProxy<T, N, M, Interfaces>...
 {
 public:
  PoolImpl() {}
  virtual ~PoolImpl() override {}
 
 protected:
- virtual BitMapObjectPool<T, N> & Impl() override { return mImpl; }
+ virtual ObjectPool<T, N, M> & Impl() override { return mImpl; }
 
 private:
- BitMapObjectPool<T, N> mImpl;
+ ObjectPool<T, N, M> mImpl;
 };
 
 } // namespace chip

src/lib/support/tests/TestPool.cpp

@@ -26,6 +26,7 @@
 #include <set>
 
 #include <lib/support/Pool.h>
+#include <lib/support/PoolWrapper.h>
 #include <lib/support/UnitTestRegistration.h>
 #include <system/SystemConfig.h>
 
@@ -53,7 +54,7 @@ using namespace chip;
 template <typename T, size_t N, ObjectPoolMem P>
 void TestReleaseNull(nlTestSuite * inSuite, void * inContext)
 {
- MemTypeObjectPool<T, N, P> pool;
+ ObjectPool<T, N, P> pool;
  pool.ReleaseObject(nullptr);
  NL_TEST_ASSERT(inSuite, GetNumObjectsInUse(pool) == 0);
  NL_TEST_ASSERT(inSuite, pool.Allocated() == 0);
@@ -74,7 +75,7 @@ void TestReleaseNullDynamic(nlTestSuite * inSuite, void * inContext)
 template <typename T, size_t N, ObjectPoolMem P>
 void TestCreateReleaseObject(nlTestSuite * inSuite, void * inContext)
 {
- MemTypeObjectPool<uint32_t, N, ObjectPoolMem::kStatic> pool;
+ ObjectPool<uint32_t, N, ObjectPoolMem::kStatic> pool;
  uint32_t * obj[N];
 
  NL_TEST_ASSERT(inSuite, pool.Allocated() == 0);
@@ -105,7 +106,7 @@ void TestCreateReleaseObjectStatic(nlTestSuite * inSuite, void * inContext)
  constexpr const size_t kSize = 100;
  TestCreateReleaseObject<uint32_t, kSize, ObjectPoolMem::kStatic>(inSuite, inContext);
 
- MemTypeObjectPool<uint32_t, kSize, ObjectPoolMem::kStatic> pool;
+ ObjectPool<uint32_t, kSize, ObjectPoolMem::kStatic> pool;
  uint32_t * obj[kSize];
 
  for (size_t i = 0; i < kSize; ++i)
@@ -159,7 +160,7 @@ void TestCreateReleaseStruct(nlTestSuite * inSuite, void * inContext)
  std::set<S *> objs1;
 
  constexpr const size_t kSize = 100;
- MemTypeObjectPool<S, kSize, P> pool;
+ ObjectPool<S, kSize, P> pool;
 
  S * objs2[kSize];
  for (size_t i = 0; i < kSize; ++i)
@@ -223,7 +224,7 @@ void TestForEachActiveObject(nlTestSuite * inSuite, void * inContext)
  S * objArray[kSize];
  std::set<size_t> objIds;
 
- MemTypeObjectPool<S, kSize, P> pool;
+ ObjectPool<S, kSize, P> pool;
 
  for (size_t i = 0; i < kSize; ++i)
  {
@@ -343,6 +344,69 @@ void TestForEachActiveObjectDynamic(nlTestSuite * inSuite, void * inContext)
 }
 #endif // CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
 
+template <ObjectPoolMem P>
+void TestPoolInterface(nlTestSuite * inSuite, void * inContext)
+{
+ struct TestObject
+ {
+ TestObject(uint32_t * set, size_t id) : mSet(set), mId(id) { *mSet |= (1 << mId); }
+ ~TestObject() { *mSet &= ~(1 << mId); }
+ uint32_t * mSet;
+ size_t mId;
+ };
+ using TestObjectPoolType = PoolInterface<TestObject, uint32_t *, size_t>;
+
+ struct PoolHolder
+ {
+ PoolHolder(TestObjectPoolType & testObjectPool) : mTestObjectPoolInterface(testObjectPool) {}
+ TestObjectPoolType & mTestObjectPoolInterface;
+ };
+
+ constexpr size_t kSize = 10;
+ PoolImpl<TestObject, kSize, P, typename TestObjectPoolType::Interface> testObjectPool;
+ PoolHolder poolHolder(testObjectPool);
+ uint32_t bits = 0;
+
+ TestObject * objs2[kSize];
+ for (size_t i = 0; i < kSize; ++i)
+ {
+ objs2[i] = poolHolder.mTestObjectPoolInterface.CreateObject(&bits, i);
+ NL_TEST_ASSERT(inSuite, objs2[i] != nullptr);
+ NL_TEST_ASSERT(inSuite, GetNumObjectsInUse(poolHolder.mTestObjectPoolInterface) == i + 1);
+ NL_TEST_ASSERT(inSuite, bits == (1ul << (i + 1)) - 1);
+ }
+ for (size_t i = 0; i < kSize; ++i)
+ {
+ poolHolder.mTestObjectPoolInterface.ReleaseObject(objs2[i]);
+ NL_TEST_ASSERT(inSuite, GetNumObjectsInUse(poolHolder.mTestObjectPoolInterface) == kSize - i - 1);
+ }
+ NL_TEST_ASSERT(inSuite, bits == 0);
+
+ // Verify that ReleaseAll() calls the destructors.
+ for (size_t i = 0; i < kSize; ++i)
+ {
+ objs2[i] = poolHolder.mTestObjectPoolInterface.CreateObject(&bits, i);
+ }
+ NL_TEST_ASSERT(inSuite, bits == (1ul << kSize) - 1);
+ NL_TEST_ASSERT(inSuite, GetNumObjectsInUse(poolHolder.mTestObjectPoolInterface) == kSize);
+
+ poolHolder.mTestObjectPoolInterface.ReleaseAll();
+ NL_TEST_ASSERT(inSuite, bits == 0);
+ NL_TEST_ASSERT(inSuite, GetNumObjectsInUse(poolHolder.mTestObjectPoolInterface) == 0);
+}
+
+void TestPoolInterfaceStatic(nlTestSuite * inSuite, void * inContext)
+{
+ TestPoolInterface<ObjectPoolMem::kStatic>(inSuite, inContext);
+}
+
+#if CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
+void TestPoolInterfaceDynamic(nlTestSuite * inSuite, void * inContext)
+{
+ TestPoolInterface<ObjectPoolMem::kDynamic>(inSuite, inContext);
+}
+#endif // CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
+
 int Setup(void * inContext)
 {
  return SUCCESS;
@@ -365,11 +429,13 @@ static const nlTest sTests[] = {
  NL_TEST_DEF_FN(TestCreateReleaseObjectStatic),
  NL_TEST_DEF_FN(TestCreateReleaseStructStatic),
  NL_TEST_DEF_FN(TestForEachActiveObjectStatic),
+ NL_TEST_DEF_FN(TestPoolInterfaceStatic),
 #if CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
  NL_TEST_DEF_FN(TestReleaseNullDynamic),
  NL_TEST_DEF_FN(TestCreateReleaseObjectDynamic),
  NL_TEST_DEF_FN(TestCreateReleaseStructDynamic),
  NL_TEST_DEF_FN(TestForEachActiveObjectDynamic),
+ NL_TEST_DEF_FN(TestPoolInterfaceDynamic),
 #endif // CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
  NL_TEST_SENTINEL()
  // clang-format on

src/transport/raw/TCP.h

@@ -281,7 +281,7 @@ class TCP : public TCPBase
 private:
  friend class TCPTest;
  TCPBase::ActiveConnectionState mConnectionsBuffer[kActiveConnectionsSize];
- PoolImpl<PendingPacket, kPendingPacketSize, PendingPacketPoolType::Interface> mPendingPackets;
+ PoolImpl<PendingPacket, kPendingPacketSize, ObjectPoolMem::kStatic, PendingPacketPoolType::Interface> mPendingPackets;
 };
 
 } // namespace Transport