Changeset 35205 in vbox for trunk/src/VBox/VMM

Timestamp:

Dec 16, 2010 6:35:02 PM (14 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

69045

Message:

AsyncCompletion: Don't waste CPU cycles when all endpoints have reached the bandwidth limit and go to sleep

Location:

trunk/src/VBox/VMM

Files:

• PDMAsyncCompletionFileInternal.h (modified) (1 diff)
• PDMAsyncCompletionFileNormal.cpp (modified) (6 diffs)

trunk/src/VBox/VMM/PDMAsyncCompletionFileInternal.h

@@ -167 +167 @@
     /** Size of the array. */
     unsigned                               cReqEntries;
-    /** Flag whether at least one endpoint reached its bandwidth limit. */
-    bool                                   fBwLimitReached;
     /** Memory cache for file range locks. */
     RTMEMCACHE                             hMemCacheRangeLocks;
+    /** Number of milliseconds to wait until the bandwidth is refreshed for at least
+     * one endpoint and it is possible to process more requests. */
+    RTMSINTERVAL                           msBwLimitExpired;
     /** Critical section protecting the blocking event handling. */
     RTCRITSECT                             CritSectBlockingEvent;

trunk/src/VBox/VMM/PDMAsyncCompletionFileNormal.cpp

@@ -59 +59 @@
     {
         /* Initialize request handle array. */
-        pAioMgr->iFreeEntry = 0;
-        pAioMgr->cReqEntries    = pAioMgr->cRequestsActiveMax;
-        pAioMgr->pahReqsFree    = (RTFILEAIOREQ *)RTMemAllocZ(pAioMgr->cReqEntries * sizeof(RTFILEAIOREQ));
+        pAioMgr->iFreeEntry       = 0;
+        pAioMgr->cReqEntries      = pAioMgr->cRequestsActiveMax;
+        pAioMgr->pahReqsFree      = (RTFILEAIOREQ *)RTMemAllocZ(pAioMgr->cReqEntries * sizeof(RTFILEAIOREQ));
+        pAioMgr->msBwLimitExpired = RT_INDEFINITE_WAIT;
 
         if (pAioMgr->pahReqsFree)
@@ -979 +980 @@
         if (!pdmacEpIsTransferAllowed(&pEndpoint->Core, (uint32_t)pCurr->DataSeg.cbSeg, &msWhenNext))
         {
-            pAioMgr->fBwLimitReached = true;
+            pAioMgr->msBwLimitExpired = RT_MIN(pAioMgr->msBwLimitExpired, msWhenNext);
             break;
         }
@@ -1090 +1091 @@
 
         if (RT_UNLIKELY(   pAioMgr->cRequestsActiveMax == pAioMgr->cRequestsActive
-                        && !pEndpoint->pFlushReq
-                        && !pAioMgr->fBwLimitReached))
+                        && !pEndpoint->pFlushReq))
         {
 #if 0
@@ -1273 +1273 @@
     PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint = pAioMgr->pEndpointsHead;
 
-    pAioMgr->fBwLimitReached = false;
+    pAioMgr->msBwLimitExpired = RT_INDEFINITE_WAIT;
 
     while (pEndpoint)
@@ -1604 +1604 @@
             ASMAtomicWriteBool(&pAioMgr->fWaitingEventSem, true);
             if (!ASMAtomicReadBool(&pAioMgr->fWokenUp))
-                rc = RTSemEventWait(pAioMgr->EventSem, RT_INDEFINITE_WAIT);
+                rc = RTSemEventWait(pAioMgr->EventSem, pAioMgr->msBwLimitExpired);
             ASMAtomicWriteBool(&pAioMgr->fWaitingEventSem, false);
-            AssertRC(rc);
+            Assert(RT_SUCCESS(rc) || rc == VERR_TIMEOUT);
 
             LogFlow(("Got woken up\n"));
@@ -1626 +1626 @@
             CHECK_RC(pAioMgr, rc);
 
-            while (   pAioMgr->cRequestsActive
-                   || pAioMgr->fBwLimitReached)
-            {
-                if (pAioMgr->cRequestsActive)
-                {
-                    RTFILEAIOREQ  apReqs[20];
-                    uint32_t cReqsCompleted = 0;
-                    size_t cReqsWait;
-
-                    if (pAioMgr->cRequestsActive > RT_ELEMENTS(apReqs))
-                        cReqsWait = RT_ELEMENTS(apReqs);
-                    else
-                        cReqsWait = pAioMgr->cRequestsActive;
-
-                    LogFlow(("Waiting for %d of %d tasks to complete\n", 1, cReqsWait));
-
-                    rc = RTFileAioCtxWait(pAioMgr->hAioCtx,
-                                          1,
-                                          RT_INDEFINITE_WAIT, apReqs,
-                                          cReqsWait, &cReqsCompleted);
-                    if (RT_FAILURE(rc) && (rc != VERR_INTERRUPTED))
-                        CHECK_RC(pAioMgr, rc);
-
-                    LogFlow(("%d tasks completed\n", cReqsCompleted));
-
-                    for (uint32_t i = 0; i < cReqsCompleted; i++)
-                        pdmacFileAioMgrNormalReqComplete(pAioMgr, apReqs[i]);
-
-                    /* Check for an external blocking event before we go to sleep again. */
-                    if (pAioMgr->fBlockingEventPending)
+            while (pAioMgr->cRequestsActive)
+            {
+                RTFILEAIOREQ apReqs[20];
+                uint32_t     cReqsCompleted = 0;
+                size_t       cReqsWait;
+
+                if (pAioMgr->cRequestsActive > RT_ELEMENTS(apReqs))
+                    cReqsWait = RT_ELEMENTS(apReqs);
+                else
+                    cReqsWait = pAioMgr->cRequestsActive;
+
+                LogFlow(("Waiting for %d of %d tasks to complete\n", 1, cReqsWait));
+
+                rc = RTFileAioCtxWait(pAioMgr->hAioCtx,
+                                      1,
+                                      RT_INDEFINITE_WAIT, apReqs,
+                                      cReqsWait, &cReqsCompleted);
+                if (RT_FAILURE(rc) && (rc != VERR_INTERRUPTED))
+                    CHECK_RC(pAioMgr, rc);
+
+                LogFlow(("%d tasks completed\n", cReqsCompleted));
+
+                for (uint32_t i = 0; i < cReqsCompleted; i++)
+                    pdmacFileAioMgrNormalReqComplete(pAioMgr, apReqs[i]);
+
+                /* Check for an external blocking event before we go to sleep again. */
+                if (pAioMgr->fBlockingEventPending)
+                {
+                    rc = pdmacFileAioMgrNormalProcessBlockingEvent(pAioMgr);
+                    CHECK_RC(pAioMgr, rc);
+                }
+
+                /* Update load statistics. */
+                uint64_t uMillisCurr = RTTimeMilliTS();
+                if (uMillisCurr > uMillisEnd)
+                {
+                    PPDMASYNCCOMPLETIONENDPOINTFILE pEndpointCurr = pAioMgr->pEndpointsHead;
+
+                    /* Calculate timespan. */
+                    uMillisCurr -= uMillisEnd;
+
+                    while (pEndpointCurr)
                     {
-                        rc = pdmacFileAioMgrNormalProcessBlockingEvent(pAioMgr);
-                        CHECK_RC(pAioMgr, rc);
+                        pEndpointCurr->AioMgr.cReqsPerSec    = pEndpointCurr->AioMgr.cReqsProcessed / (uMillisCurr + PDMACEPFILEMGR_LOAD_UPDATE_PERIOD);
+                        pEndpointCurr->AioMgr.cReqsProcessed = 0;
+                        pEndpointCurr = pEndpointCurr->AioMgr.pEndpointNext;
                     }
 
-                    /* Update load statistics. */
-                    uint64_t uMillisCurr = RTTimeMilliTS();
-                    if (uMillisCurr > uMillisEnd)
-                    {
-                        PPDMASYNCCOMPLETIONENDPOINTFILE pEndpointCurr = pAioMgr->pEndpointsHead;
-
-                        /* Calculate timespan. */
-                        uMillisCurr -= uMillisEnd;
-
-                        while (pEndpointCurr)
-                        {
-                            pEndpointCurr->AioMgr.cReqsPerSec    = pEndpointCurr->AioMgr.cReqsProcessed / (uMillisCurr + PDMACEPFILEMGR_LOAD_UPDATE_PERIOD);
-                            pEndpointCurr->AioMgr.cReqsProcessed = 0;
-                            pEndpointCurr = pEndpointCurr->AioMgr.pEndpointNext;
-                        }
-
-                        /* Set new update interval */
-                        uMillisEnd = RTTimeMilliTS() + PDMACEPFILEMGR_LOAD_UPDATE_PERIOD;
-                    }
-                }
-                else
-                {
-                    /*
-                     * Bandwidth limit reached for all endpoints.
-                     * Yield and wait until we have enough resources again.
-                     */
-                    RTThreadYield();
+                    /* Set new update interval */
+                    uMillisEnd = RTTimeMilliTS() + PDMACEPFILEMGR_LOAD_UPDATE_PERIOD;
                 }