Changeset 93631 in vbox

Timestamp:

Feb 7, 2022 12:45:08 AM (3 years ago)

Author:

vboxsync

Message:

VMM/PDMNetShaper: Don't start the unchoke thread unless there are are one or more bandwidth groups configured. Make the unchoke thread wait on an event sempahore so it can be woken up when needed and stop wasting cpu cycles and battery on lots of unnecessary wakups. Use a timer (real time clock) to wake up the unchoke timer when needed. bugref:10093 bugref:5582

Location:

trunk/src/VBox/VMM

Files:

• VMMAll/PDMAllNetShaper.cpp (modified) (3 diffs)
• VMMR3/PDMNetShaper.cpp (modified) (8 diffs)
• include/PDMInternal.h (modified) (2 diffs)

trunk/src/VBox/VMM/VMMAll/PDMAllNetShaper.cpp

@@ -60 +60 @@
                      * Re-fill the bucket first
                      */
-                    uint64_t const tsNow    = RTTimeSystemNanoTS();
-                    uint64_t const cNsDelta = tsNow - pGroup->tsUpdatedLast;
+                    uint64_t const nsNow    = RTTimeSystemNanoTS();
+                    uint64_t const cNsDelta = nsNow - pGroup->tsUpdatedLast;
                     /** @todo r=bird: there might be an overflow issue here if the gap
                      *                between two transfers is too large. */
@@ -76 +76 @@
                     {
                         pGroup->cbTokensLast  = cTokens - (uint32_t)cbTransfer;
-                        pGroup->tsUpdatedLast = tsNow;
+                        pGroup->tsUpdatedLast = nsNow;
                         Log2(("pdmNsAllocateBandwidth/%s: allowed - cbTransfer=%#zx cTokens=%#x cTokensAdded=%#x\n",
                               pGroup->szName, cbTransfer, cTokens, cTokensAdded));
@@ -82 +82 @@
                     else
                     {
+                        /*
+                         * No, we're choked.  Arm the unchoke timer for the next period.
+                         * Just do this on a simple PDM_NETSHAPER_MAX_LATENCY clock granularity.
+                         * ASSUMES the timer uses millisecond resolution clock.
+                         */
                         ASMAtomicWriteBool(&pFilter->fChoked, true);
-                        Log2(("pdmNsAllocateBandwidth/%s: refused - cbTransfer=%#zx cTokens=%#x cTokensAdded=%#x\n",
-                              pGroup->szName, cbTransfer, cTokens, cTokensAdded));
+                        if (ASMAtomicCmpXchgBool(&pVM->pdm.s.fNsUnchokeTimerArmed, true, false))
+                        {
+                            Assert(TMTimerGetFreq(pVM, pVM->pdm.s.hNsUnchokeTimer) == RT_MS_1SEC);
+                            uint64_t const msNow    = TMTimerGet(pVM, pVM->pdm.s.hNsUnchokeTimer);
+                            uint64_t const msExpire = (msNow / PDM_NETSHAPER_MAX_LATENCY + 1) * PDM_NETSHAPER_MAX_LATENCY;
+                            rc = TMTimerSet(pVM, pVM->pdm.s.hNsUnchokeTimer, msExpire);
+                            AssertRC(rc);
+
+                            Log2(("pdmNsAllocateBandwidth/%s: refused - cbTransfer=%#zx cTokens=%#x cTokensAdded=%#x cMsExpire=%u\n",
+                                  pGroup->szName, cbTransfer, cTokens, cTokensAdded, msExpire - msNow));
+                        }
+                        else
+                            Log2(("pdmNsAllocateBandwidth/%s: refused - cbTransfer=%#zx cTokens=%#x cTokensAdded=%#x\n",
+                                  pGroup->szName, cbTransfer, cTokens, cTokensAdded));
                         fAllowed = false;
                     }

trunk/src/VBox/VMM/VMMR3/PDMNetShaper.cpp

@@ -30 +30 @@
 #include <iprt/asm.h>
 #include <iprt/assert.h>
+#include <iprt/critsect.h>
+#include <iprt/string.h>
+#include <iprt/semaphore.h>
 #include <iprt/thread.h>
-#include <iprt/mem.h>
-#include <iprt/critsect.h>
-#include <iprt/tcp.h>
-#include <iprt/path.h>
-#include <iprt/string.h>
 
 #include <VBox/vmm/pdmnetshaper.h>
@@ -203 +201 @@
 
 /**
- * This is used both by pdmR3NsTxThread and PDMR3NsBwGroupSetLimit,
+ * This is used both by pdmR3NsUnchokeThread and PDMR3NsBwGroupSetLimit,
  * the latter only when setting cbPerSecMax to zero.
  *
@@ -316 +314 @@
 
 /**
- * I/O thread for pending TX.
+ * I/O thread for pending unchoking and associating transmitting.
  *
  * @returns VINF_SUCCESS (ignored).
@@ -322 +320 @@
  * @param   pThread     The PDM thread data.
  */
-static DECLCALLBACK(int) pdmR3NsTxThread(PVM pVM, PPDMTHREAD pThread)
-{
-    LogFlow(("pdmR3NsTxThread: pVM=%p\n", pVM));
+static DECLCALLBACK(int) pdmR3NsUnchokeThread(PVM pVM, PPDMTHREAD pThread)
+{
+    LogFlow(("pdmR3NsUnchokeThread: pVM=%p\n", pVM));
     while (pThread->enmState == PDMTHREADSTATE_RUNNING)
     {
-        /** @todo r=bird: This sleep is horribly crude and wasteful! (Michael would go nuts if he knew) */
-        RTThreadSleep(PDM_NETSHAPER_MAX_LATENCY);
+        int rc = RTSemEventWait(pVM->pdm.s.hNsUnchokeEvt, RT_INDEFINITE_WAIT);
+        if (pThread->enmState != PDMTHREADSTATE_RUNNING)
+            break;
+        AssertMsgStmt(RT_SUCCESS(rc) || rc == VERR_TIMEOUT /* paranioa*/, ("%Rrc\n", rc),
+                      RTThreadSleep(PDM_NETSHAPER_MAX_LATENCY));
 
         /*
@@ -336 +337 @@
          * from taking place while we're traversing the filter lists.
          */
-        int rc = RTCritSectEnter(&pVM->pdm.s.NsLock);
+        rc = RTCritSectEnter(&pVM->pdm.s.NsLock);
         AssertRC(rc);
 
@@ -358 +359 @@
  * @copydoc FNPDMTHREADWAKEUPINT
  */
-static DECLCALLBACK(int) pdmR3NsTxWakeUp(PVM pVM, PPDMTHREAD pThread)
-{
-    RT_NOREF2(pVM, pThread);
-    LogFlow(("pdmR3NsTxWakeUp: pShaper=%p\n", pThread->pvUser));
-    /* Nothing to do */
-    /** @todo r=bird: use a semaphore, this'll cause a PDM_NETSHAPER_MAX_LATENCY/2
-     *        delay every time we pause the VM! Stupid stupid stupid. */
+static DECLCALLBACK(int) pdmR3NsUnchokeWakeUp(PVM pVM, PPDMTHREAD pThread)
+{
+    LogFlow(("pdmR3NsUnchokeWakeUp:\n"));
+
+    /* Wake up the thread. */
+    int rc = RTSemEventSignal(pVM->pdm.s.hNsUnchokeEvt);
+    AssertRC(rc);
+
+    RT_NOREF(pThread);
     return VINF_SUCCESS;
+}
+
+
+/**
+ * @callback_method_impl{FNTMTIMERINT, Wakes up pdmR3NsUnchokeThread.}
+ */
+static DECLCALLBACK(void) pdmR3NsUnchokeTimer(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser)
+{
+    ASMAtomicWriteBool(&pVM->pdm.s.fNsUnchokeTimerArmed, false);
+
+    /* Wake up the thread. */
+    int rc = RTSemEventSignal(pVM->pdm.s.hNsUnchokeEvt);
+    AssertRC(rc);
+
+    RT_NOREF(hTimer, pvUser);
 }
 
@@ -400 +418 @@
     LogFlow(("pdmR3NetShaperInit: pVM=%p\n", pVM));
     VM_ASSERT_EMT(pVM);
+
+    Assert(pVM->pdm.s.cNsGroups == 0);
+    pVM->pdm.s.hNsUnchokeEvt   = NIL_RTSEMEVENT;
+    pVM->pdm.s.hNsUnchokeTimer = NIL_TMTIMERHANDLE;
 
     /*
@@ -467 +489 @@
     {
         /*
-         * Create the transmit thread.
+         * If there are any groups configured, create a unchoke thread and an
+         * associated timer for waking it up when needed.   The timer runs on
+         * the real time clock.
          */
-        rc = PDMR3ThreadCreate(pVM, &pVM->pdm.s.pNsTxThread, NULL, pdmR3NsTxThread, pdmR3NsTxWakeUp,
-                               0 /*cbStack*/, RTTHREADTYPE_IO, "PDMNsTx");
+        if (pVM->pdm.s.cNsGroups == 0)
+        {
+            LogFlowFunc(("returns VINF_SUCCESS - no groups\n"));
+            return VINF_SUCCESS;
+        }
+
+        rc = RTSemEventCreate(&pVM->pdm.s.hNsUnchokeEvt);
         if (RT_SUCCESS(rc))
         {
-            LogFlowFunc(("returns VINF_SUCCESS\n"));
-            return VINF_SUCCESS;
+            rc = TMR3TimerCreate(pVM, TMCLOCK_REAL, pdmR3NsUnchokeTimer, NULL, TMTIMER_FLAGS_NO_RING0,
+                                 "PDMNetShaperUnchoke", &pVM->pdm.s.hNsUnchokeTimer);
+            if (RT_SUCCESS(rc))
+            {
+                rc = PDMR3ThreadCreate(pVM, &pVM->pdm.s.pNsUnchokeThread, NULL, pdmR3NsUnchokeThread, pdmR3NsUnchokeWakeUp,
+                                       0 /*cbStack*/, RTTHREADTYPE_IO, "PDMNsUnchoke");
+                if (RT_SUCCESS(rc))
+                {
+
+                    LogFlowFunc(("returns VINF_SUCCESS (%u groups)\n", pVM->pdm.s.cNsGroups));
+                    return VINF_SUCCESS;
+                }
+            }
         }
     }

trunk/src/VBox/VMM/include/PDMInternal.h

@@ -1514 +1514 @@
     bool                            fStateLoaded;
     /** Alignment padding. */
-    bool                            afPadding[3];
+    bool                            afPadding1[3];
 
     /** The tracing ID of the next device instance.
@@ -1544 +1544 @@
     /** @name Network Shaper
      * @{ */
-    /** Pending TX thread. */
-    PPDMTHREAD                      pNsTxThread;
-    uint32_t                        au32Padding[1+8];
+    /** Thread that processes choked filter drivers after
+     * the a PDM_NETSHAPER_MAX_LATENCY period has elapsed. */
+    PPDMTHREAD                      pNsUnchokeThread;
+    /** Semaphore that the TX thread waits on. */
+    RTSEMEVENT                      hNsUnchokeEvt;
+    /** Timer handle for waking up pNsUnchokeThread. */
+    TMTIMERHANDLE                   hNsUnchokeTimer;
+    /** Indicates whether the unchoke timer has been armed already or not. */
+    bool volatile                   fNsUnchokeTimerArmed;
+    /** Align aNsGroups on a cacheline.   */
+    bool                            afPadding2[19];
     /** Number of network shaper groups.
      * @note Marked volatile to prevent re-reading after validation. */