Support to use heap for pool based on actual usage for large systems (#…

…8299) * Support to use heap for pool for large systems * Update src/system/SystemObject.h Co-authored-by: Michael Sandstedt <[email protected]> * Use templated foreach function to safely execute operation on each object Co-authored-by: Michael Sandstedt <[email protected]>
project-chip · Aug 21, 2021 · 5673363 · 5673363
1 parent 211e058
commit 5673363
Show file tree

Hide file tree

Showing 12 changed files with 354 additions and 73 deletions.
diff --git a/src/inet/IPEndPointBasis.h b/src/inet/IPEndPointBasis.h
@@ -106,6 +106,7 @@ class DLL_EXPORT IPEndPointBasis : public EndPointBasis
      */
     typedef void (*OnReceiveErrorFunct)(IPEndPointBasis * endPoint, CHIP_ERROR err, const IPPacketInfo * pktInfo);
 
+    IPEndPointBasis() = default;
     CHIP_ERROR SetMulticastLoopback(IPVersion aIPVersion, bool aLoopback);
     CHIP_ERROR JoinMulticastGroup(InterfaceId aInterfaceId, const IPAddress & aAddress);
     CHIP_ERROR LeaveMulticastGroup(InterfaceId aInterfaceId, const IPAddress & aAddress);
@@ -178,9 +179,7 @@ class DLL_EXPORT IPEndPointBasis : public EndPointBasis
 #endif // CHIP_SYSTEM_CONFIG_USE_PLATFORM_MULTICAST_API
 
 private:
-    IPEndPointBasis()                        = delete;
     IPEndPointBasis(const IPEndPointBasis &) = delete;
-    ~IPEndPointBasis()                       = delete;
 };
 
 #if CHIP_SYSTEM_CONFIG_USE_LWIP

diff --git a/src/inet/InetLayer.cpp b/src/inet/InetLayer.cpp
@@ -319,14 +319,13 @@ CHIP_ERROR InetLayer::Shutdown()
     {
 #if INET_CONFIG_ENABLE_DNS_RESOLVER
         // Cancel all DNS resolution requests owned by this instance.
-        for (size_t i = 0; i < DNSResolver::sPool.Size(); i++)
-        {
-            DNSResolver * lResolver = DNSResolver::sPool.Get(*mSystemLayer, i);
+        DNSResolver::sPool.ForEachActiveObject([&](DNSResolver * lResolver) {
             if ((lResolver != nullptr) && lResolver->IsCreatedByInetLayer(*this))
             {
                 lResolver->Cancel();
             }
-        }
+            return true;
+        });
 
 #if CHIP_SYSTEM_CONFIG_USE_SOCKETS && INET_CONFIG_ENABLE_ASYNC_DNS_SOCKETS
 
@@ -337,38 +336,35 @@ CHIP_ERROR InetLayer::Shutdown()
 
 #if INET_CONFIG_ENABLE_RAW_ENDPOINT
         // Close all raw endpoints owned by this Inet layer instance.
-        for (size_t i = 0; i < RawEndPoint::sPool.Size(); i++)
-        {
-            RawEndPoint * lEndPoint = RawEndPoint::sPool.Get(*mSystemLayer, i);
+        RawEndPoint::sPool.ForEachActiveObject([&](RawEndPoint * lEndPoint) {
             if ((lEndPoint != nullptr) && lEndPoint->IsCreatedByInetLayer(*this))
             {
                 lEndPoint->Close();
             }
-        }
+            return true;
+        });
 #endif // INET_CONFIG_ENABLE_RAW_ENDPOINT
 
 #if INET_CONFIG_ENABLE_TCP_ENDPOINT
         // Abort all TCP endpoints owned by this instance.
-        for (size_t i = 0; i < TCPEndPoint::sPool.Size(); i++)
-        {
-            TCPEndPoint * lEndPoint = TCPEndPoint::sPool.Get(*mSystemLayer, i);
+        TCPEndPoint::sPool.ForEachActiveObject([&](TCPEndPoint * lEndPoint) {
             if ((lEndPoint != nullptr) && lEndPoint->IsCreatedByInetLayer(*this))
             {
                 lEndPoint->Abort();
             }
-        }
+            return true;
+        });
 #endif // INET_CONFIG_ENABLE_TCP_ENDPOINT
 
 #if INET_CONFIG_ENABLE_UDP_ENDPOINT
         // Close all UDP endpoints owned by this instance.
-        for (size_t i = 0; i < UDPEndPoint::sPool.Size(); i++)
-        {
-            UDPEndPoint * lEndPoint = UDPEndPoint::sPool.Get(*mSystemLayer, i);
+        UDPEndPoint::sPool.ForEachActiveObject([&](UDPEndPoint * lEndPoint) {
             if ((lEndPoint != nullptr) && lEndPoint->IsCreatedByInetLayer(*this))
             {
                 lEndPoint->Close();
             }
-        }
+            return true;
+        });
 #endif // INET_CONFIG_ENABLE_UDP_ENDPOINT
     }
 
@@ -410,17 +406,15 @@ bool InetLayer::IsIdleTimerRunning()
 {
     bool timerRunning = false;
 
-    // see if there are any TCP connections with the idle timer check in use.
-    for (size_t i = 0; i < TCPEndPoint::sPool.Size(); i++)
-    {
-        TCPEndPoint * lEndPoint = TCPEndPoint::sPool.Get(*mSystemLayer, i);
-
+    // See if there are any TCP connections with the idle timer check in use.
+    TCPEndPoint::sPool.ForEachActiveObject([&](TCPEndPoint * lEndPoint) {
         if ((lEndPoint != nullptr) && (lEndPoint->mIdleTimeout != 0))
         {
             timerRunning = true;
-            break;
+            return false;
         }
-    }
+        return true;
+    });
 
     return timerRunning;
 }
@@ -879,40 +873,32 @@ void InetLayer::CancelResolveHostAddress(DNSResolveCompleteFunct onComplete, voi
     if (State != kState_Initialized)
         return;
 
-    for (size_t i = 0; i < DNSResolver::sPool.Size(); i++)
-    {
-        DNSResolver * lResolver = DNSResolver::sPool.Get(*mSystemLayer, i);
-
-        if (lResolver == nullptr)
-        {
-            continue;
-        }
-
+    DNSResolver::sPool.ForEachActiveObject([&](DNSResolver * lResolver) {
         if (!lResolver->IsCreatedByInetLayer(*this))
         {
-            continue;
+            return true;
         }
 
         if (lResolver->OnComplete != onComplete)
         {
-            continue;
+            return true;
         }
 
         if (lResolver->AppState != appState)
         {
-            continue;
+            return true;
         }
 
 #if CHIP_SYSTEM_CONFIG_USE_SOCKETS && INET_CONFIG_ENABLE_ASYNC_DNS_SOCKETS
         if (lResolver->mState == DNSResolver::kState_Canceled)
         {
-            continue;
+            return true;
         }
 #endif // CHIP_SYSTEM_CONFIG_USE_SOCKETS && INET_CONFIG_ENABLE_ASYNC_DNS_SOCKETS
 
         lResolver->Cancel();
-        break;
-    }
+        return false;
+    });
 }
 
 #endif // INET_CONFIG_ENABLE_DNS_RESOLVER

diff --git a/src/inet/RawEndPoint.h b/src/inet/RawEndPoint.h
@@ -74,6 +74,7 @@ class DLL_EXPORT RawEndPoint : public IPEndPointBasis
      */
     IPProtocol IPProto; // This data member is read-only
 
+    RawEndPoint() = default;
     CHIP_ERROR Bind(IPAddressType addrType, const IPAddress & addr, InterfaceId intfId = INET_NULL_INTERFACEID);
     CHIP_ERROR BindIPv6LinkLocal(InterfaceId intfId, const IPAddress & addr);
     CHIP_ERROR BindInterface(IPAddressType addrType, InterfaceId intfId);
@@ -88,9 +89,7 @@ class DLL_EXPORT RawEndPoint : public IPEndPointBasis
     void Free();
 
 private:
-    RawEndPoint()                    = delete;
     RawEndPoint(const RawEndPoint &) = delete;
-    ~RawEndPoint()                   = delete;
 
     static chip::System::ObjectPool<RawEndPoint, INET_CONFIG_NUM_RAW_ENDPOINTS> sPool;
 

diff --git a/src/inet/TCPEndPoint.h b/src/inet/TCPEndPoint.h
@@ -91,6 +91,8 @@ class DLL_EXPORT TCPEndPoint : public EndPointBasis
         kState_Closed          = 8                   /**< Endpoint closed, ready for release. */
     } State;
 
+    TCPEndPoint() = default;
+
     /**
      * @brief   Bind the endpoint to an interface IP address.
      *
@@ -637,9 +639,7 @@ class DLL_EXPORT TCPEndPoint : public EndPointBasis
 
 #endif // INET_CONFIG_OVERRIDE_SYSTEM_TCP_USER_TIMEOUT
 
-    TCPEndPoint();                    // not defined
     TCPEndPoint(const TCPEndPoint &); // not defined
-    ~TCPEndPoint();                   // not defined
 
     void Init(InetLayer * inetLayer);
     CHIP_ERROR DriveSending();

diff --git a/src/inet/UDPEndPoint.h b/src/inet/UDPEndPoint.h
@@ -56,6 +56,8 @@ class DLL_EXPORT UDPEndPoint : public IPEndPointBasis
     friend class InetLayer;
 
 public:
+    UDPEndPoint() = default;
+
     CHIP_ERROR Bind(IPAddressType addrType, const IPAddress & addr, uint16_t port, InterfaceId intfId = INET_NULL_INTERFACEID);
     CHIP_ERROR BindInterface(IPAddressType addrType, InterfaceId intfId);
     InterfaceId GetBoundInterface();
@@ -69,9 +71,7 @@ class DLL_EXPORT UDPEndPoint : public IPEndPointBasis
     void Free();
 
 private:
-    UDPEndPoint()                    = delete;
     UDPEndPoint(const UDPEndPoint &) = delete;
-    ~UDPEndPoint()                   = delete;
 
     static chip::System::ObjectPool<UDPEndPoint, INET_CONFIG_NUM_UDP_ENDPOINTS> sPool;
 

diff --git a/src/inet/tests/TestInetEndPoint.cpp b/src/inet/tests/TestInetEndPoint.cpp
@@ -488,6 +488,7 @@ static void TestInetEndPointInternal(nlTestSuite * inSuite, void * inContext)
     testTCPEP1->Shutdown();
 }
 
+#if !CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
 // Test the InetLayer resource limitation
 static void TestInetEndPointLimit(nlTestSuite * inSuite, void * inContext)
 {
@@ -496,7 +497,7 @@ static void TestInetEndPointLimit(nlTestSuite * inSuite, void * inContext)
 #endif //
     UDPEndPoint * testUDPEP = nullptr;
     TCPEndPoint * testTCPEP = nullptr;
-    CHIP_ERROR err;
+    CHIP_ERROR err          = CHIP_NO_ERROR;
     char numTimersTest[CHIP_SYSTEM_CONFIG_NUM_TIMERS + 1];
 
 #if INET_CONFIG_ENABLE_RAW_ENDPOINT
@@ -527,6 +528,7 @@ static void TestInetEndPointLimit(nlTestSuite * inSuite, void * inContext)
     ShutdownNetwork();
     ShutdownSystemLayer();
 }
+#endif
 
 // Test Suite
 
@@ -541,7 +543,9 @@ static const nlTest sTests[] = { NL_TEST_DEF("InetEndPoint::PreTest", TestInetPr
                                  NL_TEST_DEF("InetEndPoint::TestInetError", TestInetError),
                                  NL_TEST_DEF("InetEndPoint::TestInetInterface", TestInetInterface),
                                  NL_TEST_DEF("InetEndPoint::TestInetEndPoint", TestInetEndPointInternal),
+#if !CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
                                  NL_TEST_DEF("InetEndPoint::TestEndPointLimit", TestInetEndPointLimit),
+#endif
                                  NL_TEST_SENTINEL() };
 
 #if CHIP_SYSTEM_CONFIG_USE_SOCKETS

diff --git a/src/platform/Linux/SystemPlatformConfig.h b/src/platform/Linux/SystemPlatformConfig.h
@@ -38,6 +38,7 @@ struct ChipDeviceEvent;
 #define CHIP_SYSTEM_CONFIG_FREERTOS_LOCKING 0
 #define CHIP_SYSTEM_CONFIG_NO_LOCKING 0
 #define CHIP_SYSTEM_CONFIG_PLATFORM_PROVIDES_TIME 1
+#define CHIP_SYSTEM_CONFIG_POOL_USE_HEAP 1
 
 // ========== Platform-specific Configuration Overrides =========
 

diff --git a/src/system/SystemConfig.h b/src/system/SystemConfig.h
@@ -214,6 +214,15 @@
 #define CHIP_SYSTEM_CONFIG_MBED_LOCKING 0
 #endif /* CHIP_SYSTEM_CONFIG_MBED_LOCKING */
 
+/**
+ *  @def CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
+ *
+ *  @brief
+ *      Allocate Pool from Heap for large systems (e.g. Linux).
+ */
+#ifndef CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
+#define CHIP_SYSTEM_CONFIG_POOL_USE_HEAP 0
+#endif /* CHIP_SYSTEM_CONFIG_POOL_USE_HEAP */
 
 /**
  *  @def CHIP_SYSTEM_CONFIG_NO_LOCKING

diff --git a/src/system/SystemObject.cpp b/src/system/SystemObject.cpp
@@ -35,7 +35,6 @@
 // Include local headers
 #include <stddef.h>
 #include <stdlib.h>
-#include <string.h>
 
 namespace chip {
 namespace System {
@@ -52,6 +51,13 @@ DLL_EXPORT void Object::Release()
     if (oldCount == 1)
     {
         this->mSystemLayer = nullptr;
+#if CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
+        std::lock_guard<std::mutex> lock(*mMutexRef);
+        this->mPrev->mNext = this->mNext;
+        if (this->mNext)
+            this->mNext->mPrev = this->mPrev;
+        delete this;
+#endif
         __sync_synchronize();
     }
     else if (oldCount == 0)