Changeset 32430 in vbox

Timestamp:

Sep 11, 2010 4:06:37 PM (14 years ago)

Author:

vboxsync

Message:

VD: Little experiment to speed up booting from a high latency storage medium (iSCSI over a WAN network for example) by

increasing small reads and saving the result in a temporary buffer. Subsequent reads can then be served from the buffer
avoiding to read from the medium.

File:

• trunk/src/VBox/Devices/Storage/DrvVD.cpp (modified) (11 diffs)

trunk/src/VBox/Devices/Storage/DrvVD.cpp

@@ -174 +174 @@
     /** Target image index for merging. */
     unsigned            uMergeTarget;
+
+    /** Flag whether boot acceleration is enabled. */
+    bool                fBootAccelEnabled;
+    /** Flag whether boot acceleration is currently active. */
+    bool                fBootAccelActive;
+    /** Size of the disk, used for read truncation. */
+    size_t              cbDisk;
+    /** Size of the configured buffer. */
+    size_t              cbBootAccelBuffer;
+    /** Start offset for which the buffer holds data. */
+    uint64_t            offDisk;
+    /** Number of valid bytes in the buffer. */
+    size_t              cbDataValid;
+    /** The disk buffer. */
+    uint8_t            *pbData;
 } VBOXDISK, *PVBOXDISK;
 
@@ -1428 +1443 @@
                                    uint64_t off, void *pvBuf, size_t cbRead)
 {
+    int rc = VINF_SUCCESS;
+
     LogFlow(("%s: off=%#llx pvBuf=%p cbRead=%d\n", __FUNCTION__,
              off, pvBuf, cbRead));
     PVBOXDISK pThis = PDMIMEDIA_2_VBOXDISK(pInterface);
-    int rc = VDRead(pThis->pDisk, off, pvBuf, cbRead);
+
+    if (!pThis->fBootAccelActive)
+        rc = VDRead(pThis->pDisk, off, pvBuf, cbRead);
+    else
+    {
+        /* Can we serve the request from the buffer? */
+        if (   off >= pThis->offDisk
+            && off - pThis->offDisk < pThis->cbDataValid)
+        {
+            size_t cbToCopy = RT_MIN(cbRead, pThis->offDisk + pThis->cbDataValid - off);
+
+            memcpy(pvBuf, pThis->pbData + (off - pThis->offDisk), cbToCopy);
+            cbRead -= cbToCopy;
+            off    += cbToCopy;
+            pvBuf   = (char *)pvBuf + cbToCopy;
+        }
+
+        if (   cbRead > 0
+            && cbRead < pThis->cbBootAccelBuffer)
+        {
+            /* Increase request to the buffer size and read. */
+            pThis->cbDataValid = RT_MIN(pThis->cbDisk - off, pThis->cbBootAccelBuffer);
+            pThis->offDisk = off;
+            rc = VDRead(pThis->pDisk, off, pThis->pbData, pThis->cbDataValid);
+            if (RT_FAILURE(rc))
+                pThis->cbDataValid = 0;
+            else
+                memcpy(pvBuf, pThis->pbData, cbRead);
+        }
+        else if (cbRead >= pThis->cbBootAccelBuffer)
+        {
+            pThis->fBootAccelActive = false; /* Deactiviate */
+        }
+    }
+
     if (RT_SUCCESS(rc))
         Log2(("%s: off=%#llx pvBuf=%p cbRead=%d %.*Rhxd\n", __FUNCTION__,
@@ -1449 +1500 @@
     Log2(("%s: off=%#llx pvBuf=%p cbWrite=%d %.*Rhxd\n", __FUNCTION__,
           off, pvBuf, cbWrite, cbWrite, pvBuf));
+
+    /* Invalidate any buffer if boot acceleration is enabled. */
+    if (pThis->fBootAccelActive)
+    {
+        pThis->cbDataValid = 0;
+        pThis->offDisk     = 0;
+    }
+
     int rc = VDWrite(pThis->pDisk, off, pvBuf, cbWrite);
     LogFlow(("%s: returns %Rrc\n", __FUNCTION__, rc));
@@ -1614 +1673 @@
              uOffset, paSeg, cSeg, cbRead, pvUser));
     PVBOXDISK pThis = PDMIMEDIAASYNC_2_VBOXDISK(pInterface);
+
+    pThis->fBootAccelActive = false;
+
     int rc = VDAsyncRead(pThis->pDisk, uOffset, cbRead, paSeg, cSeg,
                          drvvdAsyncReqComplete, pThis, pvUser);
@@ -1627 +1689 @@
              uOffset, paSeg, cSeg, cbWrite, pvUser));
     PVBOXDISK pThis = PDMIMEDIAASYNC_2_VBOXDISK(pInterface);
+
+    pThis->fBootAccelActive = false;
+
     int rc = VDAsyncWrite(pThis->pDisk, uOffset, cbWrite, paSeg, cSeg,
                           drvvdAsyncReqComplete, pThis, pvUser);
@@ -1772 +1837 @@
 
 /**
+ * @copydoc FNPDMDRVRESET
+ */
+static DECLCALLBACK(void) drvvdReset(PPDMDRVINS pDrvIns)
+{
+    LogFlow(("%s:\n", __FUNCTION__));
+    PVBOXDISK pThis = PDMINS_2_DATA(pDrvIns, PVBOXDISK);
+
+    if (pThis->fBootAccelEnabled)
+    {
+        pThis->fBootAccelActive = true;
+        pThis->cbDataValid      = 0;
+        pThis->offDisk          = 0;
+    }
+}
+
+/**
  * @copydoc FNPDMDRVDESTRUCT
  */
@@ -1808 +1889 @@
         pThis->MergeLock = NIL_RTSEMRW;
     }
+    if (pThis->pbData)
+        RTMemFree(pThis->pbData);
 }
 
@@ -1907 +1990 @@
                                           "Format\0Path\0"
                                           "ReadOnly\0MaybeReadOnly\0TempReadOnly\0Shareable\0HonorZeroWrites\0"
-                                          "HostIPStack\0UseNewIo\0"
+                                          "HostIPStack\0UseNewIo\0BootAcceleration\0BootAccelerationBuffer\0"
                                           "SetupMerge\0MergeSource\0MergeTarget\0");
         }
@@ -1998 +2081 @@
                 rc = PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_DRIVER_INVALID_PROPERTIES,
                                       N_("DrvVD: Configuration error: Both \"ReadOnly\" and \"MergePending\" are set"));
+                break;
+            }
+            rc = CFGMR3QueryBoolDef(pCurNode, "BootAcceleration", &pThis->fBootAccelEnabled, false);
+            if (RT_FAILURE(rc))
+            {
+                rc = PDMDRV_SET_ERROR(pDrvIns, rc,
+                                      N_("DrvVD: Configuration error: Querying \"BootAcceleration\" as boolean failed"));
+                break;
+            }
+            rc = CFGMR3QueryU32Def(pCurNode, "BootAccelerationBuffer", (uint32_t *)&pThis->cbBootAccelBuffer, 16 * _1K);
+            if (RT_FAILURE(rc))
+            {
+                rc = PDMDRV_SET_ERROR(pDrvIns, rc,
+                                      N_("DrvVD: Configuration error: Querying \"BootAccelerationBuffer\" as integer failed"));
                 break;
             }
@@ -2312 +2409 @@
                                     NULL /*pfnDonePrep*/, NULL /*pfnLoadExec*/, drvvdLoadDone);
 
+    /* Setup the boot acceleration stuff if enabled. */
+    if (RT_SUCCESS(rc) && pThis->fBootAccelEnabled)
+    {
+        pThis->cbDisk = VDGetSize(pThis->pDisk, VD_LAST_IMAGE);
+        Assert(pThis->cbDisk > 0);
+        pThis->pbData = (uint8_t *)RTMemAllocZ(pThis->cbBootAccelBuffer);
+        if (pThis->pbData)
+        {
+            pThis->fBootAccelActive = true;
+            pThis->offDisk          = 0;
+            pThis->cbDataValid      = 0;
+            LogRel(("VD: Boot acceleration enabled\n"));
+        }
+        else
+            LogRel(("VD: Boot acceleration, out of memory, disabled\n"));
+    }
 
     if (RT_FAILURE(rc))
@@ -2360 +2473 @@
     drvvdPowerOn,
     /* pfnReset */
-    NULL,
+    drvvdReset,
     /* pfnSuspend */
     drvvdSuspend,