Changeset 36001 in vbox

Timestamp:

Feb 16, 2011 9:21:39 PM (14 years ago)

Author:

vboxsync

Message:

AsyncCompletion: Add a new flag to enable the host cache, to make using bandwidth groups possible for buffered I/O

Location:

trunk

Files:

• include/VBox/vmm/pdmasynccompletion.h (modified) (2 diffs)
• src/VBox/VMM/VMMR3/PDMAsyncCompletion.cpp (modified) (1 diff)
• src/VBox/VMM/VMMR3/PDMAsyncCompletionFile.cpp (modified) (2 diffs)
• src/VBox/VMM/VMMR3/PDMAsyncCompletionFileFailsafe.cpp (modified) (9 diffs)
• src/VBox/VMM/VMMR3/PDMAsyncCompletionFileNormal.cpp (modified) (1 diff)

trunk/include/VBox/vmm/pdmasynccompletion.h

@@ -228 +228 @@
  * @{ */
 /** Open the file in read-only mode. */
-#define PDMACEP_FILE_FLAGS_READ_ONLY    RT_BIT_32(0)
+#define PDMACEP_FILE_FLAGS_READ_ONLY             RT_BIT_32(0)
 /** Whether the file should not be write protected.
  * The default is to protect the file against writes by other processes
@@ -234 +234 @@
  * concurrent access which can occur if the local writeback cache is enabled.
  */
-#define PDMACEP_FILE_FLAGS_DONT_LOCK    RT_BIT_32(2)
+#define PDMACEP_FILE_FLAGS_DONT_LOCK             RT_BIT_32(2)
+/** Open the endpoint with the host cache enabled. */
+#define PDMACEP_FILE_FLAGS_HOST_CACHE_ENABLED    RT_BIT_32(3)
 /** @} */
 

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

@@ -1191 +1191 @@
 
     /* Check that the flags are valid. */
-    AssertReturn(((~(PDMACEP_FILE_FLAGS_READ_ONLY | PDMACEP_FILE_FLAGS_DONT_LOCK) & fFlags) == 0),
+    AssertReturn(((~(PDMACEP_FILE_FLAGS_READ_ONLY | PDMACEP_FILE_FLAGS_DONT_LOCK | PDMACEP_FILE_FLAGS_HOST_CACHE_ENABLED) & fFlags) == 0),
                  VERR_INVALID_PARAMETER);
 

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

@@ -431 +431 @@
         else
             pAioMgrNew->enmMgrType = pEpClass->enmMgrTypeOverride;
+
+        pAioMgrNew->msBwLimitExpired = RT_INDEFINITE_WAIT;
 
         rc = RTSemEventCreate(&pAioMgrNew->EventSem);
@@ -863 +865 @@
     PDMACFILEEPBACKEND enmEpBackend = pEpClassFile->enmEpBackendDefault;
 
-    AssertMsgReturn((fFlags & ~(PDMACEP_FILE_FLAGS_READ_ONLY | PDMACEP_FILE_FLAGS_DONT_LOCK)) == 0,
+    AssertMsgReturn((fFlags & ~(PDMACEP_FILE_FLAGS_READ_ONLY | PDMACEP_FILE_FLAGS_DONT_LOCK | PDMACEP_FILE_FLAGS_HOST_CACHE_ENABLED)) == 0,
                     ("PDMAsyncCompletion: Invalid flag specified\n"), VERR_INVALID_PARAMETER);
 
     unsigned fFileFlags = RTFILE_O_OPEN;
+
+    /*
+     * Revert to the simple manager and the buffered backend if
+     * the host cache should be enabled.
+     */
+    if (fFlags & PDMACEP_FILE_FLAGS_HOST_CACHE_ENABLED)
+    {
+        enmMgrType   = PDMACEPFILEMGRTYPE_SIMPLE;
+        enmEpBackend = PDMACFILEEPBACKEND_BUFFERED;
+    }
 
     if (fFlags & PDMACEP_FILE_FLAGS_READ_ONLY)

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

@@ -27 +27 @@
 #include "PDMAsyncCompletionFileInternal.h"
 
-
-static int pdmacFileAioMgrFailsafeProcessEndpointTaskList(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint,
+/**
+ * Put a list of tasks in the pending request list of an endpoint.
+ */
+DECLINLINE(void) pdmacFileAioMgrEpAddTaskList(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint, PPDMACTASKFILE pTaskHead)
+{
+    /* Add the rest of the tasks to the pending list */
+    if (!pEndpoint->AioMgr.pReqsPendingHead)
+    {
+        Assert(!pEndpoint->AioMgr.pReqsPendingTail);
+        pEndpoint->AioMgr.pReqsPendingHead = pTaskHead;
+    }
+    else
+    {
+        Assert(pEndpoint->AioMgr.pReqsPendingTail);
+        pEndpoint->AioMgr.pReqsPendingTail->pNext = pTaskHead;
+    }
+
+    /* Update the tail. */
+    while (pTaskHead->pNext)
+        pTaskHead = pTaskHead->pNext;
+
+    pEndpoint->AioMgr.pReqsPendingTail = pTaskHead;
+    pTaskHead->pNext = NULL;
+}
+
+/**
+ * Processes a given task list for assigned to the given endpoint.
+ */
+static int pdmacFileAioMgrFailsafeProcessEndpointTaskList(PPDMACEPFILEMGR pAioMgr,
+                                                          PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint,
                                                           PPDMACTASKFILE pTasks)
 {
@@ -35 +63 @@
     while (pTasks)
     {
+        RTMSINTERVAL msWhenNext;
         PPDMACTASKFILE pCurr = pTasks;
+
+        if (!pdmacEpIsTransferAllowed(&pEndpoint->Core, (uint32_t)pCurr->DataSeg.cbSeg, &msWhenNext))
+        {
+            pAioMgr->msBwLimitExpired = RT_MIN(pAioMgr->msBwLimitExpired, msWhenNext);
+            break;
+        }
 
         pTasks = pTasks->pNext;
@@ -80 +115 @@
     }
 
+    if (pTasks)
+    {
+        /* Add the rest of the tasks to the pending list */
+        pdmacFileAioMgrEpAddTaskList(pEndpoint, pTasks);
+    }
+
     return VINF_SUCCESS;
 }
 
-static int pdmacFileAioMgrFailsafeProcessEndpoint(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint)
+static int pdmacFileAioMgrFailsafeProcessEndpoint(PPDMACEPFILEMGR pAioMgr,
+                                                  PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint)
 {
     int rc = VINF_SUCCESS;
@@ -93 +135 @@
     /* Process the request pending list first in case the endpoint was migrated due to an error. */
     if (pTasks)
-        rc = pdmacFileAioMgrFailsafeProcessEndpointTaskList(pEndpoint, pTasks);
+        rc = pdmacFileAioMgrFailsafeProcessEndpointTaskList(pAioMgr, pEndpoint, pTasks);
 
     if (RT_SUCCESS(rc))
@@ -100 +142 @@
 
         if (pTasks)
-            rc = pdmacFileAioMgrFailsafeProcessEndpointTaskList(pEndpoint, pTasks);
+            rc = pdmacFileAioMgrFailsafeProcessEndpointTaskList(pAioMgr, pEndpoint, pTasks);
     }
 
@@ -120 +162 @@
         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"));
@@ -131 +173 @@
         while (pEndpoint)
         {
-            rc = pdmacFileAioMgrFailsafeProcessEndpoint(pEndpoint);
+            pAioMgr->msBwLimitExpired = RT_INDEFINITE_WAIT;
+            rc = pdmacFileAioMgrFailsafeProcessEndpoint(pAioMgr, pEndpoint);
             AssertRC(rc);
             pEndpoint = pEndpoint->AioMgr.pEndpointNext;
@@ -160 +203 @@
                      * if the endpoint was migrated from another endpoint.
                      */
-                    rc = pdmacFileAioMgrFailsafeProcessEndpoint(pEndpointNew);
+                    rc = pdmacFileAioMgrFailsafeProcessEndpoint(pAioMgr, pEndpointNew);
                     AssertRC(rc);
                     break;
@@ -193 +236 @@
 
                     /* Make sure all tasks finished. */
-                    rc = pdmacFileAioMgrFailsafeProcessEndpoint(pEndpointClose);
+                    rc = pdmacFileAioMgrFailsafeProcessEndpoint(pAioMgr, pEndpointClose);
                     AssertRC(rc);
                     break;

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

@@ -62 +62 @@
         pAioMgr->cReqEntries      = pAioMgr->cRequestsActiveMax;
         pAioMgr->pahReqsFree      = (RTFILEAIOREQ *)RTMemAllocZ(pAioMgr->cReqEntries * sizeof(RTFILEAIOREQ));
-        pAioMgr->msBwLimitExpired = RT_INDEFINITE_WAIT;
 
         if (pAioMgr->pahReqsFree)