Optimize BitMapObjectPool::ForEachActiveObject for code size (#8192)

src/lib/support/Pool.cpp

@@ -73,4 +73,32 @@ void StaticAllocatorBitmap::Deallocate(void * element)
  mAllocated--;
 }
 
+size_t StaticAllocatorBitmap::IndexOf(void * element)
+{
+ std::ptrdiff_t diff = static_cast<uint8_t *>(element) - static_cast<uint8_t *>(mElements);
+ assert(diff >= 0);
+ assert(static_cast<size_t>(diff) % mElementSize == 0);
+ auto index = static_cast<size_t>(diff) / mElementSize;
+ assert(index < Capacity());
+ return index;
+}
+
+bool StaticAllocatorBitmap::ForEachActiveObjectInner(void * context, Lambda lambda)
+{
+ for (size_t word = 0; word * kBitChunkSize < Capacity(); ++word)
+ {
+ auto & usage = mUsage[word];
+ auto value = usage.load(std::memory_order_relaxed);
+ for (size_t offset = 0; offset < kBitChunkSize && offset + word * kBitChunkSize < Capacity(); ++offset)
+ {
+ if ((value & (kBit1 << offset)) != 0)
+ {
+ if (!lambda(context, At(word * kBitChunkSize + offset)))
+ return false;
+ }
+ }
+ }
+ return true;
+}
+
 } // namespace chip

src/lib/support/Pool.h

@@ -65,15 +65,10 @@ class StaticAllocatorBitmap : public StaticAllocatorBase
 
 protected:
  void * At(size_t index) { return static_cast<uint8_t *>(mElements) + mElementSize * index; }
- size_t IndexOf(void * element)
- {
- std::ptrdiff_t diff = static_cast<uint8_t *>(element) - static_cast<uint8_t *>(mElements);
- assert(diff >= 0);
- assert(static_cast<size_t>(diff) % mElementSize == 0);
- auto index = static_cast<size_t>(diff) / mElementSize;
- assert(index < Capacity());
- return index;
- }
+ size_t IndexOf(void * element);
+
+ using Lambda = bool (*)(void *, void *);
+ bool ForEachActiveObjectInner(void * context, Lambda lambda);
 
 private:
  void * mElements;
@@ -119,33 +114,35 @@ class BitMapObjectPool : public StaticAllocatorBitmap
  * @brief
  * Run a functor for each active object in the pool
  *
- * @param f  The functor of type `bool (*)(T*)`, return false to break the iteration
- * @return bool Returns false if broke during iteration
+ * @param function The functor of type `bool (*)(T*)`, return false to break the iteration
+ * @return bool  Returns false if broke during iteration
  *
  * caution
  * this function is not thread-safe, make sure all usage of the
  * pool is protected by a lock, or else avoid using this function
  */
- template <typename F>
- bool ForEachActiveObject(F f)
+ template <typename Function>
+ bool ForEachActiveObject(Function && function)
  {
- for (size_t word = 0; word * kBitChunkSize < Capacity(); ++word)
- {
- auto & usage = mUsage[word];
- auto value = usage.load(std::memory_order_relaxed);
- for (size_t offset = 0; offset < kBitChunkSize && offset + word * kBitChunkSize < Capacity(); ++offset)
- {
- if ((value & (kBit1 << offset)) != 0)
- {
- if (!f(static_cast<T *>(At(word * kBitChunkSize + offset))))
- return false;
- }
- }
- }
- return true;
+ LambdaProxy<Function> proxy(std::forward<Function>(function));
+ return ForEachActiveObjectInner(&proxy, &LambdaProxy<Function>::Call);
  }
 
 private:
+ template <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;
+ };
+
  std::atomic<tBitChunkType> mUsage[(N + kBitChunkSize - 1) / kBitChunkSize];
  alignas(alignof(T)) uint8_t mMemory[N * sizeof(T)];
 };