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

Timestamp:

Oct 18, 2010 7:54:10 PM (15 years ago)

Author:

vboxsync

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

66762

Message:

AsyncCompletion: Move bandwidth groups to the generic code and support arbitrary grouping of endpoints into bandwidth groups.

To add a new bandwidth group use setextradata (this adds a group called Test and sets the maximum to 2 MB/s):

VBoxInternal/PDM/AsyncCompletion/File/BwGroups/Test/Max 2097152
VBoxInternal/PDM/AsyncCompletion/File/BwGroups/Test/Start 2097152
VBoxInternal/PDM/AsyncCompletion/File/BwGroups/Test/Step 0

To assign a disk to the group add:

VBoxInternal/Devices/ahci/0/LUN#0/AttachedDriver/Config/BwGroup Test

Location:

trunk/src/VBox/VMM

Files:

• PDMAsyncCompletion.cpp (modified) (8 diffs)
• PDMAsyncCompletionFile.cpp (modified) (7 diffs)
• PDMAsyncCompletionFileInternal.h (modified) (4 diffs)
• PDMAsyncCompletionFileNormal.cpp (modified) (1 diff)
• PDMAsyncCompletionInternal.h (modified) (5 diffs)

trunk/src/VBox/VMM/PDMAsyncCompletion.cpp

@@ -37 +37 @@
 #include <iprt/tcp.h>
 #include <iprt/path.h>
+#include <iprt/string.h>
 
 #include <VBox/pdmasynccompletion.h>
@@ -113 +114 @@
 } PDMASYNCCOMPLETIONTEMPLATE;
 
+/**
+ * Bandwidth control manager instance data
+ */
+typedef struct PDMACBWMGR
+{
+    /** Pointer to the next manager in the list. */
+    struct PDMACBWMGR                          *pNext;
+    /** Pointer to the shared UVM structure. */
+    PPDMASYNCCOMPLETIONEPCLASS                  pEpClass;
+    /** Identifer of the manager. */
+    char                                       *pszId;
+    /** Maximum number of bytes the endpoints are allowed to transfer (Max is 4GB/s currently) */
+    volatile uint32_t                           cbTransferPerSecMax;
+    /** Number of bytes we start with */
+    volatile uint32_t                           cbTransferPerSecStart;
+    /** Step after each update */
+    volatile uint32_t                           cbTransferPerSecStep;
+    /** Number of bytes we are allowed to transfer till the next update.
+     * Reset by the refresh timer. */
+    volatile uint32_t                           cbTransferAllowed;
+    /** Timestamp of the last update */
+    volatile uint64_t                           tsUpdatedLast;
+    /** Reference counter - How many endpoints are associated with this manager. */
+    volatile uint32_t                           cRefs;
+} PDMACBWMGR;
+/** Pointer to a bandwidth control manager pointer. */
+typedef PPDMACBWMGR *PPPDMACBWMGR;
+
 static void pdmR3AsyncCompletionPutTask(PPDMASYNCCOMPLETIONENDPOINT pEndpoint, PPDMASYNCCOMPLETIONTASK pTask);
 
@@ -565 +594 @@
 }
 
+
+static PPDMACBWMGR pdmacBwMgrFindById(PPDMASYNCCOMPLETIONEPCLASS pEpClass, const char *pcszId)
+{
+    PPDMACBWMGR pBwMgr = NULL;
+
+    if (VALID_PTR(pcszId))
+    {
+        int rc;
+        rc = RTCritSectEnter(&pEpClass->CritSect);
+        AssertRC(rc);
+
+        pBwMgr = pEpClass->pBwMgrsHead;
+        while (   pBwMgr
+               && RTStrCmp(pBwMgr->pszId, pcszId))
+            pBwMgr = pBwMgr->pNext;
+
+        rc = RTCritSectLeave(&pEpClass->CritSect);
+        AssertRC(rc);
+    }
+
+    return pBwMgr;
+}
+
+static void pdmacBwMgrLink(PPDMACBWMGR pBwMgr)
+{
+    PPDMASYNCCOMPLETIONEPCLASS pEpClass = pBwMgr->pEpClass;
+    int rc;
+
+    rc = RTCritSectEnter(&pEpClass->CritSect);
+    AssertRC(rc);
+
+    pBwMgr->pNext = pEpClass->pBwMgrsHead;
+    pEpClass->pBwMgrsHead = pBwMgr;
+
+    rc = RTCritSectLeave(&pEpClass->CritSect);
+    AssertRC(rc);
+}
+
+static void pdmacBwMgrUnlink(PPDMACBWMGR pBwMgr)
+{
+    int rc;
+    PPDMASYNCCOMPLETIONEPCLASS pEpClass = pBwMgr->pEpClass;
+
+    rc = RTCritSectEnter(&pEpClass->CritSect);
+    AssertRC(rc);
+
+    if (pBwMgr == pEpClass->pBwMgrsHead)
+        pEpClass->pBwMgrsHead = pBwMgr->pNext;
+    else
+    {
+        PPDMACBWMGR pPrev = pEpClass->pBwMgrsHead;
+        while (   pPrev
+               && pPrev->pNext != pBwMgr)
+            pPrev = pPrev->pNext;
+
+        AssertPtr(pPrev);
+        pPrev->pNext = pBwMgr->pNext;
+    }
+
+    rc = RTCritSectLeave(&pEpClass->CritSect);
+    AssertRC(rc);
+}
+
+static int pdmacAsyncCompletionBwMgrCreate(PPDMASYNCCOMPLETIONEPCLASS pEpClass, const char *pcszBwMgr, uint32_t cbTransferPerSecMax,
+                                           uint32_t cbTransferPerSecStart, uint32_t cbTransferPerSecStep)
+{
+    int rc = VINF_SUCCESS;
+    PPDMACBWMGR pBwMgr;
+
+    LogFlowFunc(("pEpClass=%#p pcszBwMgr=%#p{%s} cbTransferPerSecMax=%u cbTransferPerSecStart=%u cbTransferPerSecStep=%u\n",
+                 pEpClass, pcszBwMgr, cbTransferPerSecMax, cbTransferPerSecStart, cbTransferPerSecStep));
+
+    AssertPtrReturn(pEpClass, VERR_INVALID_POINTER);
+    AssertPtrReturn(pcszBwMgr, VERR_INVALID_POINTER);
+    AssertReturn(*pcszBwMgr != '\0', VERR_INVALID_PARAMETER);
+
+    pBwMgr = pdmacBwMgrFindById(pEpClass, pcszBwMgr);
+    if (!pBwMgr)
+    {
+        rc = MMR3HeapAllocZEx(pEpClass->pVM, MM_TAG_PDM_ASYNC_COMPLETION,
+                              sizeof(PDMACBWMGR),
+                              (void **)&pBwMgr);
+        if (RT_SUCCESS(rc))
+        {
+            pBwMgr->pszId = RTStrDup(pcszBwMgr);
+            if (pBwMgr->pszId)
+            {
+                pBwMgr->pEpClass              = pEpClass;
+                pBwMgr->cRefs                 = 0;
+
+                /* Init I/O flow control. */
+                pBwMgr->cbTransferPerSecMax   = cbTransferPerSecMax;
+                pBwMgr->cbTransferPerSecStart = cbTransferPerSecStart;
+                pBwMgr->cbTransferPerSecStep  = cbTransferPerSecStep;
+
+                pBwMgr->cbTransferAllowed     = pBwMgr->cbTransferPerSecStart;
+                pBwMgr->tsUpdatedLast         = RTTimeSystemNanoTS();
+
+                pdmacBwMgrLink(pBwMgr);
+                rc = VINF_SUCCESS;
+            }
+            else
+            {
+                rc = VERR_NO_MEMORY;
+                MMR3HeapFree(pBwMgr);
+            }
+        }
+    }
+    else
+        rc = VERR_ALREADY_EXISTS;
+
+    LogFlowFunc(("returns rc=%Rc\n", rc));
+    return rc;
+}
+
+DECLINLINE(void) pdmacBwMgrRef(PPDMACBWMGR pBwMgr)
+{
+    ASMAtomicIncU32(&pBwMgr->cRefs);
+}
+
+DECLINLINE(void) pdmacBwMgrUnref(PPDMACBWMGR pBwMgr)
+{
+    Assert(pBwMgr->cRefs > 0);
+    ASMAtomicDecU32(&pBwMgr->cRefs);
+}
+
+bool pdmacEpIsTransferAllowed(PPDMASYNCCOMPLETIONENDPOINT pEndpoint, uint32_t cbTransfer, RTMSINTERVAL *pmsWhenNext)
+{
+    bool fAllowed = true;
+    PPDMACBWMGR pBwMgr = ASMAtomicReadPtrT(&pEndpoint->pBwMgr, PPDMACBWMGR);
+
+    LogFlowFunc(("pEndpoint=%p pBwMgr=%p cbTransfer=%u\n", pEndpoint, pBwMgr, cbTransfer));
+
+    if (pBwMgr)
+    {
+        uint32_t cbOld = ASMAtomicSubU32(&pBwMgr->cbTransferAllowed, cbTransfer);
+        if (RT_LIKELY(cbOld >= cbTransfer))
+            fAllowed = true;
+        else
+        {
+            fAllowed = false;
+
+            /* We are out of ressources  Check if we can update again. */
+            uint64_t tsNow          = RTTimeSystemNanoTS();
+            uint64_t tsUpdatedLast  = ASMAtomicUoReadU64(&pBwMgr->tsUpdatedLast);
+
+            if (tsNow - tsUpdatedLast >= (1000*1000*1000))
+            {
+                if (ASMAtomicCmpXchgU64(&pBwMgr->tsUpdatedLast, tsNow, tsUpdatedLast))
+                {
+                    if (pBwMgr->cbTransferPerSecStart < pBwMgr->cbTransferPerSecMax)
+                    {
+                       pBwMgr->cbTransferPerSecStart = RT_MIN(pBwMgr->cbTransferPerSecMax, pBwMgr->cbTransferPerSecStart + pBwMgr->cbTransferPerSecStep);
+                       LogFlow(("AIOMgr: Increasing maximum bandwidth to %u bytes/sec\n", pBwMgr->cbTransferPerSecStart));
+                    }
+
+                    /* Update */
+                    ASMAtomicWriteU32(&pBwMgr->cbTransferAllowed, pBwMgr->cbTransferPerSecStart - cbTransfer);
+                    fAllowed = true;
+                    LogFlow(("AIOMgr: Refreshed bandwidth\n"));
+                }
+            }
+            else
+            {
+                ASMAtomicAddU32(&pBwMgr->cbTransferAllowed, cbTransfer);
+                *pmsWhenNext = ((1000*1000*1000) - (tsNow - tsUpdatedLast)) / (1000*1000);
+            }
+        }
+    }
+
+    LogFlowFunc(("fAllowed=%RTbool\n", fAllowed));
+
+    return fAllowed;
+}
+
 void pdmR3AsyncCompletionCompleteTask(PPDMASYNCCOMPLETIONTASK pTask, int rc, bool fCallCompletionHandler)
 {
@@ -649 +853 @@
                 if (RT_SUCCESS(rc))
                 {
-                    PUVM pUVM = pVM->pUVM;
-                    AssertMsg(!pUVM->pdm.s.apAsyncCompletionEndpointClass[pEpClassOps->enmClassType],
-                              ("Endpoint class was already initialized\n"));
-
-                    pUVM->pdm.s.apAsyncCompletionEndpointClass[pEpClassOps->enmClassType] = pEndpointClass;
-                    LogFlowFunc((": Initialized endpoint class \"%s\" rc=%Rrc\n", pEpClassOps->pcszName, rc));
-                    return VINF_SUCCESS;
+                    /* Create all bandwidth groups for resource control. */
+                    PCFGMNODE pCfgBwGrp = CFGMR3GetChild(pCfgNodeClass, "BwGroups");
+
+                    if (pCfgBwGrp)
+                    {
+                        for (PCFGMNODE pCur = CFGMR3GetFirstChild(pCfgBwGrp); pCur; pCur = CFGMR3GetNextChild(pCur))
+                        {
+                            uint32_t cbMax, cbStart, cbStep;
+                            size_t cchName = CFGMR3GetNameLen(pCur) + 1;
+                            char *pszBwGrpId = (char *)RTMemAllocZ(cchName);
+
+                            if (!pszBwGrpId)
+                            {
+                                rc = VERR_NO_MEMORY;
+                                break;
+                            }
+
+                            rc = CFGMR3GetName(pCur, pszBwGrpId, cchName);
+                            AssertRC(rc);
+
+                            if (RT_SUCCESS(rc))
+                                rc = CFGMR3QueryU32(pCur, "Start", &cbStart);
+                            if (RT_SUCCESS(rc))
+                                rc = CFGMR3QueryU32(pCur, "Max", &cbMax);
+                            if (RT_SUCCESS(rc))
+                                rc = CFGMR3QueryU32(pCur, "Step", &cbStep);
+                            if (RT_SUCCESS(rc))
+                                rc = pdmacAsyncCompletionBwMgrCreate(pEndpointClass, pszBwGrpId, cbMax, cbStart, cbStep);
+
+                            RTMemFree(pszBwGrpId);
+
+                            if (RT_FAILURE(rc))
+                                break;
+                        }
+                    }
+
+                    if (RT_SUCCESS(rc))
+                    {
+                        PUVM pUVM = pVM->pUVM;
+                        AssertMsg(!pUVM->pdm.s.apAsyncCompletionEndpointClass[pEpClassOps->enmClassType],
+                                  ("Endpoint class was already initialized\n"));
+
+                        pUVM->pdm.s.apAsyncCompletionEndpointClass[pEpClassOps->enmClassType] = pEndpointClass;
+                        LogFlowFunc((": Initialized endpoint class \"%s\" rc=%Rrc\n", pEpClassOps->pcszName, rc));
+                        return VINF_SUCCESS;
+                    }
                 }
                 RTMemCacheDestroy(pEndpointClass->hMemCacheTasks);
@@ -686 +929 @@
         PDMR3AsyncCompletionEpClose(pEndpointClass->pEndpointsHead);
 
+    /* Destroy the bandwidth managers. */
+    PPDMACBWMGR pBwMgr = pEndpointClass->pBwMgrsHead;
+    while (pBwMgr)
+    {
+        PPDMACBWMGR pFree = pBwMgr;
+        pBwMgr = pBwMgr->pNext;
+        MMR3HeapFree(pFree);
+    }
+
     /* Call the termination callback of the class. */
     pEndpointClass->pEndpointOps->pfnTerminate(pEndpointClass);
@@ -738 +990 @@
 
     return VINF_SUCCESS;
+}
+
+/**
+ * Resume worker for the async completion manager.
+ *
+ * @returns nothing.
+ * @param   pVM Pointer to the shared VM structure.
+ */
+void pdmR3AsyncCompletionResume(PVM pVM)
+{
+    LogFlowFunc((": pVM=%p\n", pVM));
+    PUVM pUVM = pVM->pUVM;
+
+    /* Log the bandwidth groups and all assigned endpoints. */
+    for (size_t i = 0; i < RT_ELEMENTS(pUVM->pdm.s.apAsyncCompletionEndpointClass); i++)
+        if (pUVM->pdm.s.apAsyncCompletionEndpointClass[i])
+        {
+            PPDMASYNCCOMPLETIONEPCLASS pEpClass = pUVM->pdm.s.apAsyncCompletionEndpointClass[i];
+            PPDMASYNCCOMPLETIONENDPOINT pEp;
+            PPDMACBWMGR pBwMgr = pEpClass->pBwMgrsHead;
+
+            if (pBwMgr)
+                LogRel(("AIOMgr: Bandwidth groups for class '%s'\n", i == PDMASYNCCOMPLETIONEPCLASSTYPE_FILE
+                                                                     ? "File" : "<Unknown>"));
+
+            while (pBwMgr)
+            {
+                LogRel(("AIOMgr:     Id:    %s\n", pBwMgr->pszId));
+                LogRel(("AIOMgr:     Max:   %u B/s\n", pBwMgr->cbTransferPerSecMax));
+                LogRel(("AIOMgr:     Start: %u B/s\n", pBwMgr->cbTransferPerSecStart));
+                LogRel(("AIOMgr:     Step:  %u B/s\n", pBwMgr->cbTransferPerSecStep));
+                LogRel(("AIOMgr:     Endpoints:\n"));
+
+                pEp = pEpClass->pEndpointsHead;
+                while (pEp)
+                {
+                    if (pEp->pBwMgr == pBwMgr)
+                        LogRel(("AIOMgr:         %s\n", pEp->pszUri));
+
+                    pEp = pEp->pNext;
+                }
+
+                pBwMgr = pBwMgr->pNext;
+            }
+
+            /* Print all endpoints without assigned bandwidth groups. */
+            pEp = pEpClass->pEndpointsHead;
+            if (pEp)
+                LogRel(("AIOMgr: Endpoints without assigned bandwidth groups:\n"));
+
+            while (pEp)
+            {
+                if (!pEp->pBwMgr)
+                    LogRel(("AIOMgr:     %s\n", pEp->pszUri));
+
+                pEp = pEp->pNext;
+            }
+        }
 }
 
@@ -914 +1224 @@
             pEndpoint->pszUri            = RTStrDup(pszFilename);
             pEndpoint->cUsers            = 1;
+            pEndpoint->pBwMgr            = NULL;
 
 #ifdef VBOX_WITH_STATISTICS
@@ -1243 +1554 @@
 }
 
+VMMR3DECL(int) PDMR3AsyncCompletionEpSetBwMgr(PPDMASYNCCOMPLETIONENDPOINT pEndpoint,
+                                              const char *pcszBwMgr)
+{
+    int rc = VINF_SUCCESS;
+    AssertReturn(VALID_PTR(pEndpoint), VERR_INVALID_POINTER);
+    PPDMACBWMGR pBwMgrOld = NULL;
+    PPDMACBWMGR pBwMgrNew = NULL;
+
+    if (pcszBwMgr)
+    {
+        pBwMgrNew = pdmacBwMgrFindById(pEndpoint->pEpClass, pcszBwMgr);
+
+        if (pBwMgrNew)
+            pdmacBwMgrRef(pBwMgrNew);
+        else
+            rc = VERR_NOT_FOUND;
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        pBwMgrOld = ASMAtomicXchgPtrT(&pEndpoint->pBwMgr, pBwMgrNew, PPDMACBWMGR);
+
+        if (pBwMgrOld)
+            pdmacBwMgrUnref(pBwMgrOld);
+    }
+
+    return rc;
+}
+
 VMMR3DECL(int) PDMR3AsyncCompletionTaskCancel(PPDMASYNCCOMPLETIONTASK pTask)
 {

trunk/src/VBox/VMM/PDMAsyncCompletionFile.cpp

@@ -467 +467 @@
 }
 
-static int pdmacFileBwMgrInitialize(PPDMASYNCCOMPLETIONEPCLASSFILE pEpClassFile,
-                                    PCFGMNODE pCfgNode, PPPDMACFILEBWMGR ppBwMgr)
-{
-    int rc = VINF_SUCCESS;
-    PPDMACFILEBWMGR pBwMgr = NULL;
-
-    rc = MMR3HeapAllocZEx(pEpClassFile->Core.pVM, MM_TAG_PDM_ASYNC_COMPLETION,
-                          sizeof(PDMACFILEBWMGR),
-                          (void **)&pBwMgr);
-    if (RT_SUCCESS(rc))
-    {
-        /* Init I/O flow control. */
-        rc = CFGMR3QueryU32Def(pCfgNode, "VMTransferPerSecMax", &pBwMgr->cbVMTransferPerSecMax, UINT32_MAX);
-        AssertLogRelRCReturn(rc, rc);
-        rc = CFGMR3QueryU32Def(pCfgNode, "VMTransferPerSecStart", &pBwMgr->cbVMTransferPerSecStart, UINT32_MAX /*5 * _1M*/);
-        AssertLogRelRCReturn(rc, rc);
-        rc = CFGMR3QueryU32Def(pCfgNode, "VMTransferPerSecStep", &pBwMgr->cbVMTransferPerSecStep, _1M);
-        AssertLogRelRCReturn(rc, rc);
-
-        pBwMgr->cbVMTransferAllowed = pBwMgr->cbVMTransferPerSecStart;
-        pBwMgr->tsUpdatedLast       = RTTimeSystemNanoTS();
-
-        if (pBwMgr->cbVMTransferPerSecMax != UINT32_MAX)
-            LogRel(("AIOMgr: I/O bandwidth limited to %u bytes/sec\n", pBwMgr->cbVMTransferPerSecMax));
-        else
-            LogRel(("AIOMgr: I/O bandwidth not limited\n"));
-
-        *ppBwMgr = pBwMgr;
-    }
-
-    return rc;
-}
-
-static void pdmacFileBwMgrDestroy(PPDMACFILEBWMGR pBwMgr)
-{
-    MMR3HeapFree(pBwMgr);
-}
-
-static void pdmacFileBwRef(PPDMACFILEBWMGR pBwMgr)
-{
-    pBwMgr->cRefs++;
-}
-
-static void pdmacFileBwUnref(PPDMACFILEBWMGR pBwMgr)
-{
-    Assert(pBwMgr->cRefs > 0);
-    pBwMgr->cRefs--;
-}
-
-bool pdmacFileBwMgrIsTransferAllowed(PPDMACFILEBWMGR pBwMgr, uint32_t cbTransfer)
-{
-    bool fAllowed = true;
-
-    LogFlowFunc(("pBwMgr=%p cbTransfer=%u\n", pBwMgr, cbTransfer));
-
-    if (pBwMgr->cbVMTransferPerSecMax != UINT32_MAX) /* No need to check if bandwidth is unlimited. */
-    {
-        uint32_t cbOld = ASMAtomicSubU32(&pBwMgr->cbVMTransferAllowed, cbTransfer);
-        if (RT_LIKELY(cbOld >= cbTransfer))
-            fAllowed = true;
-        else
-        {
-            fAllowed = false;
-
-            /* We are out of ressources  Check if we can update again. */
-            uint64_t tsNow          = RTTimeSystemNanoTS();
-            uint64_t tsUpdatedLast  = ASMAtomicUoReadU64(&pBwMgr->tsUpdatedLast);
-
-            if (tsNow - tsUpdatedLast >= (1000*1000*1000))
-            {
-                if (ASMAtomicCmpXchgU64(&pBwMgr->tsUpdatedLast, tsNow, tsUpdatedLast))
-                {
-                    if (pBwMgr->cbVMTransferPerSecStart < pBwMgr->cbVMTransferPerSecMax)
-                    {
-                       pBwMgr->cbVMTransferPerSecStart = RT_MIN(pBwMgr->cbVMTransferPerSecMax, pBwMgr->cbVMTransferPerSecStart + pBwMgr->cbVMTransferPerSecStep);
-                       LogFlow(("AIOMgr: Increasing maximum bandwidth to %u bytes/sec\n", pBwMgr->cbVMTransferPerSecStart));
-                    }
-
-                    /* Update */
-                    ASMAtomicWriteU32(&pBwMgr->cbVMTransferAllowed, pBwMgr->cbVMTransferPerSecStart - cbTransfer);
-                    fAllowed = true;
-                    LogFlow(("AIOMgr: Refreshed bandwidth\n"));
-                }
-            }
-            else
-                ASMAtomicAddU32(&pBwMgr->cbVMTransferAllowed, cbTransfer);
-        }
-    }
-
-    LogFlowFunc(("fAllowed=%RTbool\n", fAllowed));
-
-    return fAllowed;
-}
-
 static int pdmacFileMgrTypeFromName(const char *pszVal, PPDMACEPFILEMGRTYPE penmMgrType)
 {
@@ -763 +669 @@
         else
             LogRel(("AIOMgr: Cache was globally disabled\n"));
-
-        rc = pdmacFileBwMgrInitialize(pEpClassFile, pCfgNode, &pEpClassFile->pBwMgr);
-        if (RT_FAILURE(rc))
-            RTCritSectDelete(&pEpClassFile->CritSect);
     }
 
@@ -788 +690 @@
 
     RTCritSectDelete(&pEpClassFile->CritSect);
-    pdmacFileBwMgrDestroy(pEpClassFile->pBwMgr);
 }
 
@@ -921 +822 @@
                 pEpFile->pTasksFreeTail = pEpFile->pTasksFreeHead;
                 pEpFile->cTasksCached   = 0;
-                pEpFile->pBwMgr         = pEpClassFile->pBwMgr;
                 pEpFile->enmBackendType = enmEpBackend;
                 /*
@@ -932 +832 @@
                 pEpFile->fAsyncFlushSupported = false;
 #endif
-                pdmacFileBwRef(pEpFile->pBwMgr);
 
                 if (enmMgrType == PDMACEPFILEMGRTYPE_SIMPLE)
@@ -984 +883 @@
                         RTMemFree(pEpFile->AioMgr.pTreeRangesLocked);
                         MMR3HeapFree(pEpFile->pTasksFreeHead);
-                        pdmacFileBwUnref(pEpFile->pBwMgr);
                     }
                 }
@@ -1062 +960 @@
         MMR3HeapFree(pTaskFree);
     }
-
-    /* Remove from the bandwidth manager */
-    pdmacFileBwUnref(pEpFile->pBwMgr);
 
     /* Destroy the locked ranges tree now. */

trunk/src/VBox/VMM/PDMAsyncCompletionFileInternal.h

@@ -211 +211 @@
 
 /**
- * Bandwidth control manager instance data
- */
-typedef struct PDMACFILEBWMGR
-{
-    /** Maximum number of bytes the VM is allowed to transfer (Max is 4GB/s) */
-    uint32_t          cbVMTransferPerSecMax;
-    /** Number of bytes we start with */
-    uint32_t          cbVMTransferPerSecStart;
-    /** Step after each update */
-    uint32_t          cbVMTransferPerSecStep;
-    /** Number of bytes we are allowed to transfer till the next update.
-     * Reset by the refresh timer. */
-    volatile uint32_t cbVMTransferAllowed;
-    /** Timestamp of the last update */
-    volatile uint64_t tsUpdatedLast;
-    /** Reference counter - How many endpoints are associated with this manager. */
-    uint32_t          cRefs;
-} PDMACFILEBWMGR;
-/** Pointer to a bandwidth control manager */
-typedef PDMACFILEBWMGR *PPDMACFILEBWMGR;
-/** Pointer to a bandwidth control manager pointer */
-typedef PPDMACFILEBWMGR *PPPDMACFILEBWMGR;
-
-/**
  * A file access range lock.
  */
@@ -459 +435 @@
     /** Flag whether the out of resources warning was printed already. */
     bool                                fOutOfResourcesWarningPrinted;
-    /** The global bandwidth control manager */
-    PPDMACFILEBWMGR                     pBwMgr;
 } PDMASYNCCOMPLETIONEPCLASSFILE;
 /** Pointer to the endpoint class data. */
@@ -547 +521 @@
     /** Cache of endpoint data. */
     PDMACFILEENDPOINTCACHE                 DataCache;
-    /** Pointer to the associated bandwidth control manager */
-    PPDMACFILEBWMGR                        pBwMgr;
 
     /** Flag whether a flush request is currently active */
@@ -714 +686 @@
 void pdmacFileEpTaskCompleted(PPDMACTASKFILE pTask, void *pvUser, int rc);
 
-bool pdmacFileBwMgrIsTransferAllowed(PPDMACFILEBWMGR pBwMgr, uint32_t cbTransfer);
-
 int pdmacFileCacheInit(PPDMASYNCCOMPLETIONEPCLASSFILE pClassFile, PCFGMNODE pCfgNode);
 void pdmacFileCacheDestroy(PPDMASYNCCOMPLETIONEPCLASSFILE pClassFile);

trunk/src/VBox/VMM/PDMAsyncCompletionFileNormal.cpp

@@ -974 +974 @@
            && RT_SUCCESS(rc))
     {
+        RTMSINTERVAL msWhenNext;
         PPDMACTASKFILE pCurr = pTaskHead;
 
-        if (!pdmacFileBwMgrIsTransferAllowed(pEndpoint->pBwMgr, (uint32_t)pCurr->DataSeg.cbSeg))
+        if (!pdmacEpIsTransferAllowed(&pEndpoint->Core, (uint32_t)pCurr->DataSeg.cbSeg, &msWhenNext))
         {
             pAioMgr->fBwLimitReached = true;

trunk/src/VBox/VMM/PDMAsyncCompletionInternal.h

@@ -161 +161 @@
 #define PDMAC_EPCLASS_OPS_VERSION 0x00000001
 
+/** Pointer to a bandwidth control manager. */
+typedef struct PDMACBWMGR *PPDMACBWMGR;
+
 /**
  * PDM Async completion endpoint class.
@@ -169 +172 @@
     /** Pointer to the shared VM structure. */
     PVM                                         pVM;
-    /** Critical section protecting the endpoint list. */
+    /** Critical section protecting the lists below. */
     RTCRITSECT                                  CritSect;
     /** Number of endpoints in the list. */
@@ -175 +178 @@
     /** Head of endpoints with this class. */
     R3PTRTYPE(PPDMASYNCCOMPLETIONENDPOINT)      pEndpointsHead;
+    /** Head of the bandwidth managers for this class. */
+    R3PTRTYPE(PPDMACBWMGR)                      pBwMgrsHead;
     /** Pointer to the callback table. */
     R3PTRTYPE(PCPDMASYNCCOMPLETIONEPCLASSOPS)   pEndpointOps;
@@ -205 +210 @@
     /** URI describing the endpoint */
     char                                       *pszUri;
+    /** Pointer to the assigned bandwidth manager. */
+    volatile PPDMACBWMGR                        pBwMgr;
 #ifdef VBOX_WITH_STATISTICS
     STAMCOUNTER                                 StatTaskRunTimesNs[10];
@@ -252 +259 @@
 void pdmR3AsyncCompletionCompleteTask(PPDMASYNCCOMPLETIONTASK pTask, int rc, bool fCallCompletionHandler);
 
+/**
+ * Checks if the endpoint is allowed to transfer the given amount of bytes.
+ *
+ * @returns true if the endpoint is allowed to transfer the data.
+ *          false otherwise
+ * @param   pEndpoint                 The endpoint.
+ * @param   cbTransfer                The number of bytes to transfer.
+ * @param   pmsWhenNext               Where to store the number of milliseconds
+ *                                    until the bandwidth is refreshed.
+ *                                    Only set if false is returned.
+ */
+bool pdmacEpIsTransferAllowed(PPDMASYNCCOMPLETIONENDPOINT pEndpoint, uint32_t cbTransfer, RTMSINTERVAL *pmsWhenNext);
+
 RT_C_DECLS_END