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

Timestamp:

Mar 5, 2025 5:33:56 PM (2 months ago)

Author:

vboxsync

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

167834

Message:

VMM/PDMAsyncCompletion: Use 64-bit types for the bandwidth group limits, ticketref:22328

Location:

trunk/src/VBox/VMM

Files:

• VMMR3/PDMAsyncCompletion.cpp (modified) (9 diffs)
• VMMR3/PDMAsyncCompletionFileFailsafe.cpp (modified) (1 diff)
• VMMR3/PDMAsyncCompletionFileNormal.cpp (modified) (1 diff)
• include/PDMAsyncCompletionInternal.h (modified) (1 diff)

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

@@ -139 +139 @@
     char                                       *pszId;
     /** Maximum number of bytes the endpoints are allowed to transfer (Max is 4GB/s currently) */
-    volatile uint32_t                           cbTransferPerSecMax;
+    volatile uint64_t                           cbTransferPerSecMax;
     /** Number of bytes we start with */
-    volatile uint32_t                           cbTransferPerSecStart;
+    volatile uint64_t                           cbTransferPerSecStart;
     /** Step after each update */
-    volatile uint32_t                           cbTransferPerSecStep;
+    volatile uint64_t                           cbTransferPerSecStep;
     /** Number of bytes we are allowed to transfer till the next update.
      * Reset by the refresh timer. */
-    volatile uint32_t                           cbTransferAllowed;
+    volatile uint64_t                           cbTransferAllowed;
     /** Timestamp of the last update */
     volatile uint64_t                           tsUpdatedLast;
@@ -655 +655 @@
 
 /** Lazy coder. */
-static int pdmacAsyncCompletionBwMgrCreate(PPDMASYNCCOMPLETIONEPCLASS pEpClass, const char *pszBwMgr, uint32_t cbTransferPerSecMax,
-                                           uint32_t cbTransferPerSecStart, uint32_t cbTransferPerSecStep)
-{
-    LogFlowFunc(("pEpClass=%#p pszBwMgr=%#p{%s} cbTransferPerSecMax=%u cbTransferPerSecStart=%u cbTransferPerSecStep=%u\n",
+static int pdmacAsyncCompletionBwMgrCreate(PPDMASYNCCOMPLETIONEPCLASS pEpClass, const char *pszBwMgr, uint64_t cbTransferPerSecMax,
+                                           uint64_t cbTransferPerSecStart, uint64_t cbTransferPerSecStep)
+{
+    LogFlowFunc(("pEpClass=%#p pszBwMgr=%#p{%s} cbTransferPerSecMax=%RU64 cbTransferPerSecStart=%RU64 cbTransferPerSecStep=%RU64\n",
                  pEpClass, pszBwMgr, pszBwMgr, cbTransferPerSecMax, cbTransferPerSecStart, cbTransferPerSecStep));
 
@@ -732 +732 @@
  *                                    Only set if false is returned.
  */
-bool pdmacEpIsTransferAllowed(PPDMASYNCCOMPLETIONENDPOINT pEndpoint, uint32_t cbTransfer, RTMSINTERVAL *pmsWhenNext)
+bool pdmacEpIsTransferAllowed(PPDMASYNCCOMPLETIONENDPOINT pEndpoint, uint64_t cbTransfer, RTMSINTERVAL *pmsWhenNext)
 {
     bool        fAllowed = true;
     PPDMACBWMGR pBwMgr = ASMAtomicReadPtrT(&pEndpoint->pBwMgr, PPDMACBWMGR);
 
-    LogFlowFunc(("pEndpoint=%p pBwMgr=%p cbTransfer=%u\n", pEndpoint, pBwMgr, cbTransfer));
+    LogFlowFunc(("pEndpoint=%p pBwMgr=%p cbTransfer=%RU64\n", pEndpoint, pBwMgr, cbTransfer));
 
     if (pBwMgr)
     {
-        uint32_t cbOld = ASMAtomicSubU32(&pBwMgr->cbTransferAllowed, cbTransfer);
+        uint64_t cbOld = ASMAtomicSubU64(&pBwMgr->cbTransferAllowed, cbTransfer);
         if (RT_LIKELY(cbOld >= cbTransfer))
             fAllowed = true;
@@ -759 +759 @@
                     {
                        pBwMgr->cbTransferPerSecStart = RT_MIN(pBwMgr->cbTransferPerSecMax, pBwMgr->cbTransferPerSecStart + pBwMgr->cbTransferPerSecStep);
-                       LogFlow(("AIOMgr: Increasing maximum bandwidth to %u bytes/sec\n", pBwMgr->cbTransferPerSecStart));
+                       LogFlow(("AIOMgr: Increasing maximum bandwidth to %RU64 bytes/sec\n", pBwMgr->cbTransferPerSecStart));
                     }
 
                     /* Update */
-                    uint32_t cbTransferAllowedNew =   pBwMgr->cbTransferPerSecStart > cbTransfer
+                    uint64_t cbTransferAllowedNew =   pBwMgr->cbTransferPerSecStart > cbTransfer
                                                     ? pBwMgr->cbTransferPerSecStart - cbTransfer
                                                     : 0;
-                    ASMAtomicWriteU32(&pBwMgr->cbTransferAllowed, cbTransferAllowedNew);
+                    ASMAtomicWriteU64(&pBwMgr->cbTransferAllowed, cbTransferAllowedNew);
                     fAllowed = true;
                     LogFlow(("AIOMgr: Refreshed bandwidth\n"));
@@ -773 +773 @@
             else
             {
-                ASMAtomicAddU32(&pBwMgr->cbTransferAllowed, cbTransfer);
+                ASMAtomicAddU64(&pBwMgr->cbTransferAllowed, cbTransfer);
                 *pmsWhenNext = ((1000*1000*1000) - (tsNow - tsUpdatedLast)) / (1000*1000);
             }
@@ -883 +883 @@
                                 if (RT_SUCCESS(rc))
                                 {
-                                    uint32_t cbMax;
-                                    rc = CFGMR3QueryU32(pCur, "Max", &cbMax);
+                                    uint64_t cbMax;
+                                    rc = CFGMR3QueryU64(pCur, "Max", &cbMax);
                                     if (RT_SUCCESS(rc))
                                     {
-                                        uint32_t cbStart;
-                                        rc = CFGMR3QueryU32Def(pCur, "Start", &cbStart, cbMax);
+                                        uint64_t cbStart;
+                                        rc = CFGMR3QueryU64Def(pCur, "Start", &cbStart, cbMax);
                                         if (RT_SUCCESS(rc))
                                         {
-                                            uint32_t cbStep;
-                                            rc = CFGMR3QueryU32Def(pCur, "Step", &cbStep, 0);
+                                            uint64_t cbStep;
+                                            rc = CFGMR3QueryU64Def(pCur, "Step", &cbStep, 0);
                                             if (RT_SUCCESS(rc))
                                                 rc = pdmacAsyncCompletionBwMgrCreate(pEndpointClass, pszBwGrpId,
@@ -1304 +1304 @@
             {
                 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:     Max:   %RU64 B/s\n", pBwMgr->cbTransferPerSecMax));
+                LogRel(("AIOMgr:     Start: %RU64 B/s\n", pBwMgr->cbTransferPerSecStart));
+                LogRel(("AIOMgr:     Step:  %RU64 B/s\n", pBwMgr->cbTransferPerSecStep));
                 LogRel(("AIOMgr:     Endpoints:\n"));
 
@@ -1781 +1781 @@
  * @param   cbMaxNew        The new maximum for the bandwidth manager in bytes/sec.
  */
-VMMR3DECL(int) PDMR3AsyncCompletionBwMgrSetMaxForFile(PUVM pUVM, const char *pszBwMgr, uint32_t cbMaxNew)
+VMMR3DECL(int) PDMR3AsyncCompletionBwMgrSetMaxForFile(PUVM pUVM, const char *pszBwMgr, uint64_t cbMaxNew)
 {
     UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
@@ -1797 +1797 @@
          * the new limit immediately.
          */
-        ASMAtomicWriteU32(&pBwMgr->cbTransferPerSecMax, cbMaxNew);
-        ASMAtomicWriteU32(&pBwMgr->cbTransferPerSecStart, cbMaxNew);
+        ASMAtomicWriteU64(&pBwMgr->cbTransferPerSecMax, cbMaxNew);
+        ASMAtomicWriteU64(&pBwMgr->cbTransferPerSecStart, cbMaxNew);
     }
     else

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

@@ -79 +79 @@
         PPDMACTASKFILE pCurr = pTasks;
 
-        if (!pdmacEpIsTransferAllowed(&pEndpoint->Core, (uint32_t)pCurr->DataSeg.cbSeg, &msWhenNext))
+        if (!pdmacEpIsTransferAllowed(&pEndpoint->Core, pCurr->DataSeg.cbSeg, &msWhenNext))
         {
             pAioMgr->msBwLimitExpired = RT_MIN(pAioMgr->msBwLimitExpired, msWhenNext);

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

@@ -999 +999 @@
         PPDMACTASKFILE pCurr = pTaskHead;
 
-        if (!pdmacEpIsTransferAllowed(&pEndpoint->Core, (uint32_t)pCurr->DataSeg.cbSeg, &msWhenNext))
+        if (!pdmacEpIsTransferAllowed(&pEndpoint->Core, pCurr->DataSeg.cbSeg, &msWhenNext))
         {
             pAioMgr->msBwLimitExpired = RT_MIN(pAioMgr->msBwLimitExpired, msWhenNext);

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

@@ -282 +282 @@
 
 void pdmR3AsyncCompletionCompleteTask(PPDMASYNCCOMPLETIONTASK pTask, int rc, bool fCallCompletionHandler);
-bool pdmacEpIsTransferAllowed(PPDMASYNCCOMPLETIONENDPOINT pEndpoint, uint32_t cbTransfer, RTMSINTERVAL *pmsWhenNext);
+bool pdmacEpIsTransferAllowed(PPDMASYNCCOMPLETIONENDPOINT pEndpoint, uint64_t cbTransfer, RTMSINTERVAL *pmsWhenNext);
 
 RT_C_DECLS_END