diff --git a/src/lib/support/Pool.cpp b/src/lib/support/Pool.cpp
index 5e4af82f3e6e46..ff8789e3c0a956 100644
--- a/src/lib/support/Pool.cpp
+++ b/src/lib/support/Pool.cpp
@@ -23,6 +23,8 @@
 
 namespace chip {
 
+namespace internal {
+
 StaticAllocatorBitmap::StaticAllocatorBitmap(void * storage, std::atomic<tBitChunkType> * usage, size_t capacity,
                                              size_t elementSize) :
     StaticAllocatorBase(capacity),
@@ -46,7 +48,7 @@ void * StaticAllocatorBitmap::Allocate()
             {
                 if (usage.compare_exchange_strong(value, value | (kBit1 << offset)))
                 {
-                    mAllocated++;
+                    IncreaseUsage();
                     return At(word * kBitChunkSize + offset);
                 }
                 else
@@ -70,7 +72,7 @@ void StaticAllocatorBitmap::Deallocate(void * element)
 
     auto value = mUsage[word].fetch_and(~(kBit1 << offset));
     nlASSERT((value & (kBit1 << offset)) != 0); // assert fail when free an unused slot
-    mAllocated--;
+    DecreaseUsage();
 }
 
 size_t StaticAllocatorBitmap::IndexOf(void * element)
@@ -83,7 +85,7 @@ size_t StaticAllocatorBitmap::IndexOf(void * element)
     return index;
 }
 
-bool StaticAllocatorBitmap::ForEachActiveObjectInner(void * context, Lambda lambda)
+bool StaticAllocatorBitmap::ForEachActiveObjectInner(void * context, bool lambda(void * context, void * object))
 {
     for (size_t word = 0; word * kBitChunkSize < Capacity(); ++word)
     {
@@ -101,4 +103,63 @@ bool StaticAllocatorBitmap::ForEachActiveObjectInner(void * context, Lambda lamb
     return true;
 }
 
+#if CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
+
+HeapObjectListNode * HeapObjectList::FindNode(void * object) const
+{
+    for (HeapObjectListNode * p = mNext; p != this; p = p->mNext)
+    {
+        if (p->mObject == object)
+        {
+            return p;
+        }
+    }
+    return nullptr;
+}
+
+using Lambda = bool (*)(void *, void *);
+bool HeapObjectList::ForEachNode(void * context, bool lambda(void * context, void * object))
+{
+    ++mIterationDepth;
+    bool result            = true;
+    bool anyReleased       = false;
+    HeapObjectListNode * p = mNext;
+    while (p != this)
+    {
+        if (p->mObject != nullptr)
+        {
+            if (!lambda(context, p->mObject))
+            {
+                result = false;
+                break;
+            }
+        }
+        if (p->mObject == nullptr)
+        {
+            anyReleased = true;
+        }
+        p = p->mNext;
+    }
+    --mIterationDepth;
+    if (mIterationDepth == 0 && anyReleased)
+    {
+        // Remove nodes for released objects.
+        p = mNext;
+        while (p != this)
+        {
+            HeapObjectListNode * next = p->mNext;
+            if (p->mObject == nullptr)
+            {
+                p->Remove();
+                delete p;
+            }
+            p = next;
+        }
+    }
+    return result;
+}
+
+#endif // CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
+
+} // namespace internal
 } // namespace chip
diff --git a/src/lib/support/Pool.h b/src/lib/support/Pool.h
index f9fe67aaa8d735..47df3efd9ef729 100644
--- a/src/lib/support/Pool.h
+++ b/src/lib/support/Pool.h
@@ -17,36 +17,57 @@
  */
 
 /**
- * @file
- *   Defines a memory pool class BitMapObjectPool.
+ * Defines memory pool classes.
  */
 
 #pragma once
 
-#include <array>
+#include <lib/support/CodeUtils.h>
+
 #include <assert.h>
 #include <atomic>
 #include <limits>
 #include <new>
 #include <stddef.h>
+#include <utility>
 
 namespace chip {
 
-class StaticAllocatorBase
+namespace internal {
+
+class Statistics
 {
 public:
-    StaticAllocatorBase(size_t capacity) : mAllocated(0), mCapacity(capacity) {}
+    Statistics() : mAllocated(0), mHighWaterMark(0) {}
 
-    size_t Capacity() const { return mCapacity; }
     size_t Allocated() const { return mAllocated; }
-    bool Exhausted() const { return mAllocated == mCapacity; }
+    size_t HighWaterMark() const { return mHighWaterMark; }
+    void IncreaseUsage()
+    {
+        if (++mAllocated > mHighWaterMark)
+        {
+            mHighWaterMark = mAllocated;
+        }
+    }
+    void DecreaseUsage() { --mAllocated; }
 
 protected:
     size_t mAllocated;
+    size_t mHighWaterMark;
+};
+
+class StaticAllocatorBase : public Statistics
+{
+public:
+    StaticAllocatorBase(size_t capacity) : mCapacity(capacity) {}
+    size_t Capacity() const { return mCapacity; }
+    bool Exhausted() const { return mAllocated == mCapacity; }
+
+protected:
     const size_t mCapacity;
 };
 
-class StaticAllocatorBitmap : public StaticAllocatorBase
+class StaticAllocatorBitmap : public internal::StaticAllocatorBase
 {
 protected:
     /**
@@ -67,8 +88,7 @@ class StaticAllocatorBitmap : public StaticAllocatorBase
     void * At(size_t index) { return static_cast<uint8_t *>(mElements) + mElementSize * index; }
     size_t IndexOf(void * element);
 
-    using Lambda = bool (*)(void *, void *);
-    bool ForEachActiveObjectInner(void * context, Lambda lambda);
+    bool ForEachActiveObjectInner(void * context, bool lambda(void * context, void * object));
 
 private:
     void * mElements;
@@ -76,20 +96,111 @@ class StaticAllocatorBitmap : public StaticAllocatorBase
     std::atomic<tBitChunkType> * mUsage;
 };
 
+template <class T>
+class PoolCommon
+{
+public:
+    template <typename... Args>
+    void ResetObject(T * element, Args &&... args)
+    {
+        element->~T();
+        new (element) T(std::forward<Args>(args)...);
+    }
+};
+
+template <typename T, typename Function>
+class LambdaProxy
+{
+public:
+    LambdaProxy(Function && function) : mFunction(std::move(function)) {}
+    static bool Call(void * context, void * target)
+    {
+        return static_cast<LambdaProxy *>(context)->mFunction(static_cast<T *>(target));
+    }
+
+private:
+    Function mFunction;
+};
+
+#if CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
+
+struct HeapObjectListNode
+{
+    void Remove()
+    {
+        mNext->mPrev = mPrev;
+        mPrev->mNext = mNext;
+    }
+
+    void * mObject;
+    HeapObjectListNode * mNext;
+    HeapObjectListNode * mPrev;
+};
+
+struct HeapObjectList : HeapObjectListNode
+{
+    HeapObjectList() : mIterationDepth(0) { mNext = mPrev = this; }
+
+    void Append(HeapObjectListNode * node)
+    {
+        node->mNext  = this;
+        node->mPrev  = mPrev;
+        mPrev->mNext = node;
+        mPrev        = node;
+    }
+
+    HeapObjectListNode * FindNode(void * object) const;
+
+    bool ForEachNode(void * context, bool lambda(void * context, void * object));
+
+    size_t mIterationDepth;
+};
+
+#endif // CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
+
+} // namespace internal
+
+/**
+ * @class ObjectPool
+ *
+ * Depending on build configuration, ObjectPool is either a fixed-size static pool or a heap-allocated pool.
+ *
+ * @tparam T    Type of element to be allocated.
+ * @tparam N    Number of elements in the pool, in the fixed-size case.
+ *
+ * @fn CreateObject
+ * @memberof ObjectPool
+ *
+ * Create an object from the pool. Forwards its arguments to construct a T.
+ *
+ * @fn ReleaseObject
+ * @memberof ObjectPool
+ * @param object   Pointer to object to release (or return to the pool). Its destructor runs.
+ *
+ * @fn ForEachActiveObject
+ * @memberof ObjectPool
+ * @param visitor   A function that takes a T* and returns true to continue iterating or false to stop iterating.
+ * @returns false if a visitor call returned false, true otherwise.
+ *
+ * Iteration may be nested. ReleaseObject() can be called during iteration, on the current object or any other.
+ * CreateObject() can be called, but it is undefined whether or not a newly created object will be visited.
+ */
+
 /**
- *  @brief
- *   A class template used for allocating Objects.
+ * A class template used for allocating objects from a fixed-size static pool.
  *
- *  @tparam     T   a subclass of element to be allocated.
+ *  @tparam     T   type of element to be allocated.
  *  @tparam     N   a positive integer max number of elements the pool provides.
  */
 template <class T, size_t N>
-class BitMapObjectPool : public StaticAllocatorBitmap
+class BitMapObjectPool : public internal::StaticAllocatorBitmap, public internal::PoolCommon<T>
 {
 public:
     BitMapObjectPool() : StaticAllocatorBitmap(mData.mMemory, mUsage, N, sizeof(T)) {}
-
-    static size_t Size() { return N; }
+    ~BitMapObjectPool()
+    {
+        // ReleaseAll();
+    }
 
     template <typename... Args>
     T * CreateObject(Args &&... args)
@@ -110,12 +221,7 @@ class BitMapObjectPool : public StaticAllocatorBitmap
         Deallocate(element);
     }
 
-    template <typename... Args>
-    void ResetObject(T * element, Args &&... args)
-    {
-        element->~T();
-        new (element) T(std::forward<Args>(args)...);
-    }
+    void ReleaseAll() { ForEachActiveObjectInner(this, ReleaseObject); }
 
     /**
      * @brief
@@ -131,24 +237,16 @@ class BitMapObjectPool : public StaticAllocatorBitmap
     template <typename Function>
     bool ForEachActiveObject(Function && function)
     {
-        LambdaProxy<Function> proxy(std::forward<Function>(function));
-        return ForEachActiveObjectInner(&proxy, &LambdaProxy<Function>::Call);
+        internal::LambdaProxy<T, Function> proxy(std::forward<Function>(function));
+        return ForEachActiveObjectInner(&proxy, &internal::LambdaProxy<T, Function>::Call);
     }
 
 private:
-    template <typename Function>
-    class LambdaProxy
+    static bool ReleaseObject(void * context, void * object)
     {
-    public:
-        LambdaProxy(Function && function) : mFunction(std::move(function)) {}
-        static bool Call(void * context, void * target)
-        {
-            return static_cast<LambdaProxy *>(context)->mFunction(static_cast<T *>(target));
-        }
-
-    private:
-        Function mFunction;
-    };
+        static_cast<BitMapObjectPool *>(context)->ReleaseObject(static_cast<T *>(object));
+        return true;
+    }
 
     std::atomic<tBitChunkType> mUsage[(N + kBitChunkSize - 1) / kBitChunkSize];
     union Data
@@ -160,4 +258,115 @@ class BitMapObjectPool : public StaticAllocatorBitmap
     } mData;
 };
 
+#if CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
+
+/**
+ * A class template used for allocating objects from the heap.
+ *
+ *  @tparam     T   type to be allocated.
+ */
+template <class T>
+class HeapObjectPool : public internal::Statistics, public internal::PoolCommon<T>
+{
+public:
+    HeapObjectPool() {}
+    ~HeapObjectPool()
+    {
+        // TODO(#11880): Release all active objects (or verify that none are active) when destroying the pool.
+        // ReleaseAll();
+    }
+
+    template <typename... Args>
+    T * CreateObject(Args &&... args)
+    {
+        T * object = new T(std::forward<Args>(args)...);
+        if (object != nullptr)
+        {
+            auto node = new internal::HeapObjectListNode();
+            if (node != nullptr)
+            {
+                node->mObject = object;
+                mObjects.Append(node);
+                IncreaseUsage();
+                return object;
+            }
+        }
+        return nullptr;
+    }
+
+    void ReleaseObject(T * object)
+    {
+        if (object != nullptr)
+        {
+            internal::HeapObjectListNode * node = mObjects.FindNode(object);
+            if (node != nullptr)
+            {
+                // Note that the node is not removed here; that is deferred until the end of the next pool iteration.
+                node->mObject = nullptr;
+                delete object;
+                DecreaseUsage();
+            }
+        }
+    }
+
+    void ReleaseAll() { mObjects.ForEachNode(this, ReleaseObject); }
+
+    /**
+     * @brief
+     *   Run a functor for each active object in the pool
+     *
+     *  @param     function The functor of type `bool (*)(T*)`, return false to break the iteration
+     *  @return    bool     Returns false if broke during iteration
+     */
+    template <typename Function>
+    bool ForEachActiveObject(Function && function)
+    {
+        // return ForEachNode([function](void *object) { return function(static_cast<T*>(object)); });
+        internal::LambdaProxy<T, Function> proxy(std::forward<Function>(function));
+        return mObjects.ForEachNode(&proxy, &internal::LambdaProxy<T, Function>::Call);
+    }
+
+private:
+    static bool ReleaseObject(void * context, void * object)
+    {
+        static_cast<HeapObjectPool *>(context)->ReleaseObject(static_cast<T *>(object));
+        return true;
+    }
+
+    internal::HeapObjectList mObjects;
+};
+
+#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
+#endif // CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
+};
+
+template <typename T, size_t N, ObjectPoolMem P>
+class MemTypeObjectPool;
+
+template <typename T, size_t N>
+class MemTypeObjectPool<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>
+{
+};
+#endif // CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
+
 } // namespace chip
diff --git a/src/lib/support/tests/TestPool.cpp b/src/lib/support/tests/TestPool.cpp
index 57366ff2b3ce8f..613bb87d00d578 100644
--- a/src/lib/support/tests/TestPool.cpp
+++ b/src/lib/support/tests/TestPool.cpp
@@ -32,8 +32,8 @@
 
 namespace chip {
 
-template <class T, size_t N>
-size_t GetNumObjectsInUse(BitMapObjectPool<T, N> & pool)
+template <class POOL>
+size_t GetNumObjectsInUse(POOL & pool)
 {
     size_t count = 0;
     pool.ForEachActiveObject([&count](void *) {
@@ -49,21 +49,65 @@ namespace {
 
 using namespace chip;
 
+template <typename T, size_t N, ObjectPoolMem P>
 void TestReleaseNull(nlTestSuite * inSuite, void * inContext)
 {
-    constexpr const size_t size = 10;
-    BitMapObjectPool<uint32_t, size> pool;
+    MemTypeObjectPool<T, N, P> pool;
     pool.ReleaseObject(nullptr);
     NL_TEST_ASSERT(inSuite, GetNumObjectsInUse(pool) == 0);
     NL_TEST_ASSERT(inSuite, pool.Allocated() == 0);
 }
 
+void TestReleaseNullStatic(nlTestSuite * inSuite, void * inContext)
+{
+    TestReleaseNull<uint32_t, 10, ObjectPoolMem::kStatic>(inSuite, inContext);
+}
+
+#if CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
+void TestReleaseNullDynamic(nlTestSuite * inSuite, void * inContext)
+{
+    TestReleaseNull<uint32_t, 10, ObjectPoolMem::kDynamic>(inSuite, inContext);
+}
+#endif // CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
+
+template <typename T, size_t N, ObjectPoolMem P>
 void TestCreateReleaseObject(nlTestSuite * inSuite, void * inContext)
 {
-    constexpr const size_t size = 100;
-    BitMapObjectPool<uint32_t, size> pool;
-    uint32_t * obj[size];
-    for (size_t i = 0; i < pool.Size(); ++i)
+    MemTypeObjectPool<uint32_t, N, ObjectPoolMem::kStatic> pool;
+    uint32_t * obj[N];
+
+    NL_TEST_ASSERT(inSuite, pool.Allocated() == 0);
+    for (int t = 0; t < 2; ++t)
+    {
+        pool.ReleaseAll();
+        NL_TEST_ASSERT(inSuite, pool.Allocated() == 0);
+
+        for (size_t i = 0; i < N; ++i)
+        {
+            obj[i] = pool.CreateObject();
+            NL_TEST_ASSERT(inSuite, obj[i] != nullptr);
+            NL_TEST_ASSERT(inSuite, GetNumObjectsInUse(pool) == i + 1);
+            NL_TEST_ASSERT(inSuite, pool.Allocated() == i + 1);
+        }
+    }
+
+    for (size_t i = 0; i < N; ++i)
+    {
+        pool.ReleaseObject(obj[i]);
+        NL_TEST_ASSERT(inSuite, GetNumObjectsInUse(pool) == N - i - 1);
+        NL_TEST_ASSERT(inSuite, pool.Allocated() == N - i - 1);
+    }
+}
+
+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;
+    uint32_t * obj[kSize];
+
+    for (size_t i = 0; i < kSize; ++i)
     {
         obj[i] = pool.CreateObject();
         NL_TEST_ASSERT(inSuite, obj[i] != nullptr);
@@ -73,33 +117,34 @@ void TestCreateReleaseObject(nlTestSuite * inSuite, void * inContext)
 
     uint32_t * fail = pool.CreateObject();
     NL_TEST_ASSERT(inSuite, fail == nullptr);
-    NL_TEST_ASSERT(inSuite, GetNumObjectsInUse(pool) == size);
-    NL_TEST_ASSERT(inSuite, pool.Allocated() == size);
+    NL_TEST_ASSERT(inSuite, GetNumObjectsInUse(pool) == kSize);
+    NL_TEST_ASSERT(inSuite, pool.Allocated() == kSize);
     NL_TEST_ASSERT(inSuite, pool.Exhausted());
 
     pool.ReleaseObject(obj[55]);
-    NL_TEST_ASSERT(inSuite, GetNumObjectsInUse(pool) == size - 1);
-    NL_TEST_ASSERT(inSuite, pool.Allocated() == size - 1);
+    NL_TEST_ASSERT(inSuite, GetNumObjectsInUse(pool) == kSize - 1);
+    NL_TEST_ASSERT(inSuite, pool.Allocated() == kSize - 1);
     NL_TEST_ASSERT(inSuite, !pool.Exhausted());
     NL_TEST_ASSERT(inSuite, obj[55] == pool.CreateObject());
-    NL_TEST_ASSERT(inSuite, GetNumObjectsInUse(pool) == size);
-    NL_TEST_ASSERT(inSuite, pool.Allocated() == size);
+    NL_TEST_ASSERT(inSuite, GetNumObjectsInUse(pool) == kSize);
+    NL_TEST_ASSERT(inSuite, pool.Allocated() == kSize);
     NL_TEST_ASSERT(inSuite, pool.Exhausted());
 
     fail = pool.CreateObject();
     NL_TEST_ASSERT(inSuite, fail == nullptr);
-    NL_TEST_ASSERT(inSuite, GetNumObjectsInUse(pool) == size);
-    NL_TEST_ASSERT(inSuite, pool.Allocated() == size);
+    NL_TEST_ASSERT(inSuite, GetNumObjectsInUse(pool) == kSize);
+    NL_TEST_ASSERT(inSuite, pool.Allocated() == kSize);
     NL_TEST_ASSERT(inSuite, pool.Exhausted());
+}
 
-    for (size_t i = 0; i < pool.Size(); ++i)
-    {
-        pool.ReleaseObject(obj[i]);
-        NL_TEST_ASSERT(inSuite, GetNumObjectsInUse(pool) == size - i - 1);
-        NL_TEST_ASSERT(inSuite, pool.Allocated() == size - i - 1);
-    }
+#if CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
+void TestCreateReleaseObjectDynamic(nlTestSuite * inSuite, void * inContext)
+{
+    TestCreateReleaseObject<uint32_t, 100, ObjectPoolMem::kDynamic>(inSuite, inContext);
 }
+#endif // CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
 
+template <ObjectPoolMem P>
 void TestCreateReleaseStruct(nlTestSuite * inSuite, void * inContext)
 {
     struct S
@@ -108,26 +153,190 @@ void TestCreateReleaseStruct(nlTestSuite * inSuite, void * inContext)
         ~S() { mSet.erase(this); }
         std::set<S *> & mSet;
     };
-
     std::set<S *> objs1;
 
-    constexpr const size_t size = 100;
-    BitMapObjectPool<S, size> pool;
-    S * objs2[size];
-    for (size_t i = 0; i < pool.Size(); ++i)
+    constexpr const size_t kSize = 100;
+    MemTypeObjectPool<S, kSize, P> pool;
+
+    S * objs2[kSize];
+    for (size_t i = 0; i < kSize; ++i)
     {
         objs2[i] = pool.CreateObject(objs1);
         NL_TEST_ASSERT(inSuite, objs2[i] != nullptr);
+        NL_TEST_ASSERT(inSuite, pool.Allocated() == i + 1);
         NL_TEST_ASSERT(inSuite, GetNumObjectsInUse(pool) == i + 1);
         NL_TEST_ASSERT(inSuite, GetNumObjectsInUse(pool) == objs1.size());
     }
-    for (size_t i = 0; i < pool.Size(); ++i)
+    for (size_t i = 0; i < kSize; ++i)
     {
         pool.ReleaseObject(objs2[i]);
-        NL_TEST_ASSERT(inSuite, GetNumObjectsInUse(pool) == size - i - 1);
+        NL_TEST_ASSERT(inSuite, pool.Allocated() == kSize - i - 1);
+        NL_TEST_ASSERT(inSuite, GetNumObjectsInUse(pool) == kSize - i - 1);
         NL_TEST_ASSERT(inSuite, GetNumObjectsInUse(pool) == objs1.size());
     }
+
+    // Verify that ReleaseAll() calls the destructors.
+    for (size_t i = 0; i < kSize; ++i)
+    {
+        objs2[i] = pool.CreateObject(objs1);
+    }
+    NL_TEST_ASSERT(inSuite, objs1.size() == kSize);
+    NL_TEST_ASSERT(inSuite, pool.Allocated() == kSize);
+    NL_TEST_ASSERT(inSuite, GetNumObjectsInUse(pool) == kSize);
+    printf("allocated = %zu\n", pool.Allocated());
+    printf("highwater = %zu\n", pool.HighWaterMark());
+
+    pool.ReleaseAll();
+    printf("allocated = %zu\n", pool.Allocated());
+    printf("highwater = %zu\n", pool.HighWaterMark());
+    NL_TEST_ASSERT(inSuite, objs1.size() == 0);
+    NL_TEST_ASSERT(inSuite, GetNumObjectsInUse(pool) == 0);
+    NL_TEST_ASSERT(inSuite, pool.Allocated() == 0);
+    NL_TEST_ASSERT(inSuite, pool.HighWaterMark() == kSize);
+}
+
+void TestCreateReleaseStructStatic(nlTestSuite * inSuite, void * inContext)
+{
+    TestCreateReleaseStruct<ObjectPoolMem::kStatic>(inSuite, inContext);
+}
+
+#if CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
+void TestCreateReleaseStructDynamic(nlTestSuite * inSuite, void * inContext)
+{
+    TestCreateReleaseStruct<ObjectPoolMem::kDynamic>(inSuite, inContext);
+}
+#endif // CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
+
+template <ObjectPoolMem P>
+void TestForEachActiveObject(nlTestSuite * inSuite, void * inContext)
+{
+    struct S
+    {
+        S(size_t id) : mId(id) {}
+        size_t mId;
+    };
+
+    constexpr size_t kSize = 50;
+    S * objArray[kSize];
+    std::set<size_t> objIds;
+
+    MemTypeObjectPool<S, kSize, P> pool;
+
+    for (size_t i = 0; i < kSize; ++i)
+    {
+        objArray[i] = pool.CreateObject(i);
+        NL_TEST_ASSERT(inSuite, objArray[i] != nullptr);
+        NL_TEST_ASSERT(inSuite, objArray[i]->mId == i);
+        objIds.insert(i);
+    }
+
+    // Verify that iteration visits all objects.
+    size_t count = 0;
+    size_t sum   = 0;
+    pool.ForEachActiveObject([&](S * object) {
+        NL_TEST_ASSERT(inSuite, object != nullptr);
+        NL_TEST_ASSERT(inSuite, objIds.count(object->mId) == 1);
+        objIds.erase(object->mId);
+        ++count;
+        sum += object->mId;
+        return true;
+    });
+    NL_TEST_ASSERT(inSuite, count == kSize);
+    NL_TEST_ASSERT(inSuite, sum == kSize * (kSize - 1) / 2);
+    NL_TEST_ASSERT(inSuite, objIds.size() == 0);
+
+    // Verify that returning false stops iterating.
+    count = 0;
+    pool.ForEachActiveObject([&](S * object) {
+        objIds.insert(object->mId);
+        return ++count != kSize / 2;
+    });
+    NL_TEST_ASSERT(inSuite, count == kSize / 2);
+    NL_TEST_ASSERT(inSuite, objIds.size() == kSize / 2);
+
+    // Verify that iteration can be nested.
+    count = 0;
+    pool.ForEachActiveObject([&](S * outer) {
+        if (objIds.count(outer->mId) == 1)
+        {
+            pool.ForEachActiveObject([&](S * inner) {
+                if (inner == outer)
+                {
+                    objIds.erase(inner->mId);
+                }
+                else
+                {
+                    ++count;
+                }
+                return true;
+            });
+        }
+        return true;
+    });
+    NL_TEST_ASSERT(inSuite, count == (kSize - 1) * kSize / 2);
+    NL_TEST_ASSERT(inSuite, objIds.size() == 0);
+
+    count = 0;
+    pool.ForEachActiveObject([&](S * object) {
+        ++count;
+        if ((object->mId % 2) == 0)
+        {
+            objArray[object->mId] = nullptr;
+            pool.ReleaseObject(object);
+        }
+        else
+        {
+            objIds.insert(object->mId);
+        }
+        return true;
+    });
+    NL_TEST_ASSERT(inSuite, count == kSize);
+    NL_TEST_ASSERT(inSuite, objIds.size() == kSize / 2);
+    for (size_t i = 0; i < kSize; ++i)
+    {
+        if ((i % 2) == 0)
+        {
+            NL_TEST_ASSERT(inSuite, objArray[i] == nullptr);
+        }
+        else
+        {
+            NL_TEST_ASSERT(inSuite, objArray[i] != nullptr);
+            NL_TEST_ASSERT(inSuite, objArray[i]->mId == i);
+        }
+    }
+
+    count = 0;
+    pool.ForEachActiveObject([&](S * object) {
+        ++count;
+        if ((object->mId % 2) == 1)
+        {
+            size_t id = object->mId - 1;
+            NL_TEST_ASSERT(inSuite, objArray[id] == nullptr);
+            objArray[id] = pool.CreateObject(id);
+            NL_TEST_ASSERT(inSuite, objArray[id] != nullptr);
+        }
+        return true;
+    });
+    for (size_t i = 0; i < kSize; ++i)
+    {
+        NL_TEST_ASSERT(inSuite, objArray[i] != nullptr);
+        NL_TEST_ASSERT(inSuite, objArray[i]->mId == i);
+    }
+    NL_TEST_ASSERT(inSuite, count >= kSize / 2);
+    NL_TEST_ASSERT(inSuite, count <= kSize);
+}
+
+void TestForEachActiveObjectStatic(nlTestSuite * inSuite, void * inContext)
+{
+    TestForEachActiveObject<ObjectPoolMem::kStatic>(inSuite, inContext);
+}
+
+#if CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
+void TestForEachActiveObjectDynamic(nlTestSuite * inSuite, void * inContext)
+{
+    TestForEachActiveObject<ObjectPoolMem::kDynamic>(inSuite, inContext);
 }
+#endif // CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
 
 int Setup(void * inContext)
 {
@@ -145,8 +354,21 @@ int Teardown(void * inContext)
 /**
  *   Test Suite. It lists all the test functions.
  */
-static const nlTest sTests[] = { NL_TEST_DEF_FN(TestReleaseNull), NL_TEST_DEF_FN(TestCreateReleaseObject),
-                                 NL_TEST_DEF_FN(TestCreateReleaseStruct), NL_TEST_SENTINEL() };
+static const nlTest sTests[] = {
+    // clang-format off
+    NL_TEST_DEF_FN(TestReleaseNullStatic),
+    NL_TEST_DEF_FN(TestCreateReleaseObjectStatic),
+    NL_TEST_DEF_FN(TestCreateReleaseStructStatic),
+    NL_TEST_DEF_FN(TestForEachActiveObjectStatic),
+#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),
+#endif // CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
+    NL_TEST_SENTINEL()
+    // clang-format on
+};
 
 int TestPool()
 {
diff --git a/src/system/SystemTimer.cpp b/src/system/SystemTimer.cpp
index d9a1600802a106..7e4a606099e5ea 100644
--- a/src/system/SystemTimer.cpp
+++ b/src/system/SystemTimer.cpp
@@ -74,7 +74,7 @@ namespace System {
  *******************************************************************************
  */
 
-BitMapObjectPool<Timer, CHIP_SYSTEM_CONFIG_NUM_TIMERS> Timer::sPool;
+chip::ObjectPool<Timer, CHIP_SYSTEM_CONFIG_NUM_TIMERS> Timer::sPool;
 Stats::count_t Timer::mNumInUse      = 0;
 Stats::count_t Timer::mHighWatermark = 0;
 
diff --git a/src/system/SystemTimer.h b/src/system/SystemTimer.h
index 390307ba97f2d8..91efa2a0cfcdca 100644
--- a/src/system/SystemTimer.h
+++ b/src/system/SystemTimer.h
@@ -229,7 +229,7 @@ class DLL_EXPORT Timer
 
 private:
     friend class LayerImplLwIP;
-    static BitMapObjectPool<Timer, CHIP_SYSTEM_CONFIG_NUM_TIMERS> sPool;
+    static chip::ObjectPool<Timer, CHIP_SYSTEM_CONFIG_NUM_TIMERS> sPool;
     static Stats::count_t mNumInUse;
     static Stats::count_t mHighWatermark;