VirtualBox

Changeset 24356 in vbox for trunk/src/VBox


Ignore:
Timestamp:
Nov 4, 2009 8:32:13 PM (15 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
54379
Message:

AsyncCompletion: Improve write performance for random acess. If a cache entry is still in progress if a write to the same entry occurs the buffer is deprecated and a new one is created which will hold the data until the write to the file completed

Location:
trunk/src/VBox/VMM
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/VMM/PDMAsyncCompletionFileCache.cpp

    r24278 r24356  
    4545*******************************************************************************/
    4646#define LOG_GROUP LOG_GROUP_PDM_ASYNC_COMPLETION
     47#define RT_STRICT
    4748#include <iprt/types.h>
    4849#include <iprt/mem.h>
    … …  
    269270                && (ASMAtomicReadU32(&pCurr->cRefs) == 0))
    270271            {
     272                AssertMsg(!(pCurr->fFlags & PDMACFILECACHE_ENTRY_IS_DEPRECATED),
     273                          ("This entry is deprecated so it should have the I/O in progress flag set\n"));
     274                Assert(!pCurr->pbDataReplace);
     275
    271276                LogFlow(("Evicting entry %#p (%u bytes)\n", pCurr, pCurr->cbData));
     277
    272278                if (pCurr->pbData)
    273279                {
    … …  
    502508    if (pTask->enmTransferType == PDMACTASKFILETRANSFER_WRITE)
    503509    {
    504         pEntry->fFlags &= ~PDMACFILECACHE_ENTRY_IS_DIRTY;
    505 
    506         while (pCurr)
     510        if (pEntry->fFlags & PDMACFILECACHE_ENTRY_IS_DEPRECATED)
    507511        {
    508             AssertMsg(pCurr->fWrite, ("Completed write entries should never have read tasks attached\n"));
    509 
    510             memcpy(pEntry->pbData + pCurr->uBufOffset, pCurr->pvBuf, pCurr->cbTransfer);
    511             pEntry->fFlags |= PDMACFILECACHE_ENTRY_IS_DIRTY;
    512 
    513             uint32_t uOld = ASMAtomicSubU32(&pCurr->pTask->cbTransferLeft, pCurr->cbTransfer);
    514             AssertMsg(uOld >= pCurr->cbTransfer, ("New value would overflow\n"));
    515             if (!(uOld - pCurr->cbTransfer)
    516                 && !ASMAtomicXchgBool(&pCurr->pTask->fCompleted, true))
    517                 pdmR3AsyncCompletionCompleteTask(&pCurr->pTask->Core);
    518 
    519             PPDMACFILETASKSEG pFree = pCurr;
    520             pCurr = pCurr->pNext;
    521 
    522             RTMemFree(pFree);
     512            AssertMsg(!pCurr, ("The entry is deprecated but has waiting write segments attached\n"));
     513
     514            RTMemPageFree(pEntry->pbData);
     515            pEntry->pbData = pEntry->pbDataReplace;
     516            pEntry->pbDataReplace = NULL;
     517            pEntry->fFlags &= ~PDMACFILECACHE_ENTRY_IS_DEPRECATED;
     518        }
     519        else
     520        {
     521            pEntry->fFlags &= ~PDMACFILECACHE_ENTRY_IS_DIRTY;
     522
     523            while (pCurr)
     524            {
     525                AssertMsg(pCurr->fWrite, ("Completed write entries should never have read tasks attached\n"));
     526
     527                memcpy(pEntry->pbData + pCurr->uBufOffset, pCurr->pvBuf, pCurr->cbTransfer);
     528                pEntry->fFlags |= PDMACFILECACHE_ENTRY_IS_DIRTY;
     529
     530                uint32_t uOld = ASMAtomicSubU32(&pCurr->pTask->cbTransferLeft, pCurr->cbTransfer);
     531                AssertMsg(uOld >= pCurr->cbTransfer, ("New value would overflow\n"));
     532                if (!(uOld - pCurr->cbTransfer)
     533                    && !ASMAtomicXchgBool(&pCurr->pTask->fCompleted, true))
     534                    pdmR3AsyncCompletionCompleteTask(&pCurr->pTask->Core);
     535
     536                PPDMACFILETASKSEG pFree = pCurr;
     537                pCurr = pCurr->pNext;
     538
     539                RTMemFree(pFree);
     540            }
    523541        }
    524542    }
    … …  
    854872        return NULL;
    855873
    856     pEntryNew->Core.Key     = off;
    857     pEntryNew->Core.KeyLast = off + cbData - 1;
    858     pEntryNew->pEndpoint    = pEndpoint;
    859     pEntryNew->pCache       = pCache;
    860     pEntryNew->fFlags       = 0;
    861     pEntryNew->cRefs        = 1; /* We are using it now. */
    862     pEntryNew->pList        = NULL;
    863     pEntryNew->cbData       = cbData;
    864     pEntryNew->pWaitingHead = NULL;
    865     pEntryNew->pWaitingTail = NULL;
    866     pEntryNew->pbData       = (uint8_t *)RTMemPageAlloc(cbData);
     874    pEntryNew->Core.Key      = off;
     875    pEntryNew->Core.KeyLast  = off + cbData - 1;
     876    pEntryNew->pEndpoint     = pEndpoint;
     877    pEntryNew->pCache        = pCache;
     878    pEntryNew->fFlags        = 0;
     879    pEntryNew->cRefs         = 1; /* We are using it now. */
     880    pEntryNew->pList         = NULL;
     881    pEntryNew->cbData        = cbData;
     882    pEntryNew->pWaitingHead  = NULL;
     883    pEntryNew->pWaitingTail  = NULL;
     884    pEntryNew->pbDataReplace = NULL;
     885    pEntryNew->pbData        = (uint8_t *)RTMemPageAlloc(cbData);
    867886
    868887    if (RT_UNLIKELY(!pEntryNew->pbData))
    … …  
    954973            pbSegBuf += BytesTransfered; \
    955974    } \
    956     while (0);
     975    while (0)
    957976
    958977/**
    … …  
    10281047                || (pEntry->pList == &pCache->LruFrequentlyUsed))
    10291048            {
    1030                 LogFlow(("Fetching data for ghost entry %#p from file\n", pEntry));
    1031 
    1032                 if (pdmacFileEpCacheEntryFlagIsSetClearAcquireLock(pEndpointCache, pEntry,
    1033                                                                    PDMACFILECACHE_ENTRY_IO_IN_PROGRESS,
    1034                                                                    PDMACFILECACHE_ENTRY_IS_DIRTY))
     1049                if(pdmacFileEpCacheEntryFlagIsSetClearAcquireLock(pEndpointCache, pEntry,
     1050                                                                  PDMACFILECACHE_ENTRY_IS_DEPRECATED,
     1051                                                                  0))
    10351052                {
    1036                     /* Entry didn't completed yet. Append to the list */
    1037                     while (cbToRead)
    1038                     {
    1039                         PPDMACFILETASKSEG pSeg = (PPDMACFILETASKSEG)RTMemAllocZ(sizeof(PDMACFILETASKSEG));
    1040 
    1041                         pSeg->pTask      = pTask;
    1042                         pSeg->uBufOffset = OffDiff;
    1043                         pSeg->cbTransfer = RT_MIN(cbToRead, cbSegLeft);
    1044                         pSeg->pvBuf      = pbSegBuf;
    1045                         pSeg->fWrite     = false;
    1046 
    1047                         ADVANCE_SEGMENT_BUFFER(pSeg->cbTransfer);
    1048 
    1049                         pdmacFileEpCacheEntryAddWaitingSegment(pEntry, pSeg);
    1050 
    1051                         off      += pSeg->cbTransfer;
    1052                         cbToRead -= pSeg->cbTransfer;
    1053                         OffDiff  += pSeg->cbTransfer;
    1054                     }
    1055                     RTSemRWReleaseWrite(pEndpointCache->SemRWEntries);
    1056                 }
    1057                 else
    1058                 {
    1059                     /* Read as much as we can from the entry. */
     1053                    /* Entry is deprecated. Read data from the new buffer. */
    10601054                    while (cbToRead)
    10611055                    {
    10621056                        size_t cbCopy = RT_MIN(cbSegLeft, cbToRead);
    10631057
    1064                         memcpy(pbSegBuf, pEntry->pbData + OffDiff, cbCopy);
     1058                        memcpy(pbSegBuf, pEntry->pbDataReplace + OffDiff, cbCopy);
    10651059
    10661060                        ADVANCE_SEGMENT_BUFFER(cbCopy);
    … …  
    10701064                        OffDiff  += cbCopy;
    10711065                        ASMAtomicSubS32(&pTask->cbTransferLeft, cbCopy);
     1066                    }
     1067                }
     1068                else
     1069                {
     1070                    if (pdmacFileEpCacheEntryFlagIsSetClearAcquireLock(pEndpointCache, pEntry,
     1071                                                                       PDMACFILECACHE_ENTRY_IO_IN_PROGRESS,
     1072                                                                       PDMACFILECACHE_ENTRY_IS_DIRTY))
     1073                    {
     1074                        /* Entry didn't completed yet. Append to the list */
     1075                        while (cbToRead)
     1076                        {
     1077                            PPDMACFILETASKSEG pSeg = (PPDMACFILETASKSEG)RTMemAllocZ(sizeof(PDMACFILETASKSEG));
     1078
     1079                            pSeg->pTask      = pTask;
     1080                            pSeg->uBufOffset = OffDiff;
     1081                            pSeg->cbTransfer = RT_MIN(cbToRead, cbSegLeft);
     1082                            pSeg->pvBuf      = pbSegBuf;
     1083                            pSeg->fWrite     = false;
     1084
     1085                            ADVANCE_SEGMENT_BUFFER(pSeg->cbTransfer);
     1086
     1087                            pdmacFileEpCacheEntryAddWaitingSegment(pEntry, pSeg);
     1088
     1089                            off      += pSeg->cbTransfer;
     1090                            cbToRead -= pSeg->cbTransfer;
     1091                            OffDiff  += pSeg->cbTransfer;
     1092                        }
     1093                        RTSemRWReleaseWrite(pEndpointCache->SemRWEntries);
     1094                    }
     1095                    else
     1096                    {
     1097                        /* Read as much as we can from the entry. */
     1098                        while (cbToRead)
     1099                        {
     1100                            size_t cbCopy = RT_MIN(cbSegLeft, cbToRead);
     1101
     1102                            memcpy(pbSegBuf, pEntry->pbData + OffDiff, cbCopy);
     1103
     1104                            ADVANCE_SEGMENT_BUFFER(cbCopy);
     1105
     1106                            cbToRead -= cbCopy;
     1107                            off      += cbCopy;
     1108                            OffDiff  += cbCopy;
     1109                            ASMAtomicSubS32(&pTask->cbTransferLeft, cbCopy);
     1110                        }
    10721111                    }
    10731112                }
    … …  
    10801119            else
    10811120            {
     1121                LogFlow(("Fetching data for ghost entry %#p from file\n", pEntry));
     1122
    10821123                RTCritSectEnter(&pCache->CritSect);
    10831124                pdmacFileCacheUpdate(pCache, pEntry);
    … …  
    13031344                || (pEntry->pList == &pCache->LruFrequentlyUsed))
    13041345            {
    1305 
    1306                 /* If the entry is dirty it must be also in progress now and we have to defer updating it again. */
     1346                /* Check if the buffer is deprecated. */
    13071347                if(pdmacFileEpCacheEntryFlagIsSetClearAcquireLock(pEndpointCache, pEntry,
    1308                                                                   PDMACFILECACHE_ENTRY_IS_DIRTY,
     1348                                                                  PDMACFILECACHE_ENTRY_IS_DEPRECATED,
    13091349                                                                  0))
    13101350                {
    13111351                    AssertMsg(pEntry->fFlags & PDMACFILECACHE_ENTRY_IO_IN_PROGRESS,
    1312                                 ("Entry is dirty but not in progress\n"));
    1313 
    1314                     /* The data isn't written to the file yet */
     1352                                ("Entry is deprecated but not in progress\n"));
     1353                    AssertPtr(pEntry->pbDataReplace);
     1354
     1355                    LogFlow(("Writing to deprecated buffer of entry %#p\n", pEntry));
     1356
     1357                    /* Update the data from the write. */
    13151358                    while (cbToWrite)
    13161359                    {
    1317                         PPDMACFILETASKSEG pSeg = (PPDMACFILETASKSEG)RTMemAllocZ(sizeof(PDMACFILETASKSEG));
    1318 
    1319                         pSeg->pTask      = pTask;
    1320                         pSeg->uBufOffset = OffDiff;
    1321                         pSeg->cbTransfer = RT_MIN(cbToWrite, cbSegLeft);
    1322                         pSeg->pvBuf      = pbSegBuf;
    1323                         pSeg->fWrite     = true;
    1324 
    1325                         ADVANCE_SEGMENT_BUFFER(pSeg->cbTransfer);
    1326 
    1327                         pdmacFileEpCacheEntryAddWaitingSegment(pEntry, pSeg);
    1328 
    1329                         off       += pSeg->cbTransfer;
    1330                         OffDiff   += pSeg->cbTransfer;
    1331                         cbToWrite -= pSeg->cbTransfer;
     1360                        size_t cbCopy = RT_MIN(cbSegLeft, cbToWrite);
     1361
     1362                        memcpy(pEntry->pbDataReplace + OffDiff, pbSegBuf, cbCopy);
     1363
     1364                        ADVANCE_SEGMENT_BUFFER(cbCopy);
     1365
     1366                        cbToWrite-= cbCopy;
     1367                        off      += cbCopy;
     1368                        OffDiff  += cbCopy;
     1369                        ASMAtomicSubS32(&pTask->cbTransferLeft, cbCopy);
    13321370                    }
    1333                     STAM_COUNTER_INC(&pEndpointCache->StatWriteDeferred);
    13341371                    RTSemRWReleaseWrite(pEndpointCache->SemRWEntries);
    13351372                }
    13361373                else
    13371374                {
    1338                     /*
    1339                      * Check if a read is in progress for this entry.
    1340                      * We have to defer processing in that case.
    1341                      */
     1375                    /* If the entry is dirty it must be also in progress now and we have to defer updating it again. */
    13421376                    if(pdmacFileEpCacheEntryFlagIsSetClearAcquireLock(pEndpointCache, pEntry,
    1343                                                                       PDMACFILECACHE_ENTRY_IO_IN_PROGRESS,
     1377                                                                      PDMACFILECACHE_ENTRY_IS_DIRTY,
    13441378                                                                      0))
    13451379                    {
    1346                         while (cbToWrite)
     1380                        AssertMsg(pEntry->fFlags & PDMACFILECACHE_ENTRY_IO_IN_PROGRESS,
     1381                                    ("Entry is dirty but not in progress\n"));
     1382                        Assert(!pEntry->pbDataReplace);
     1383
     1384                        /* Deprecate the current buffer. */
     1385                        if (!pEntry->pWaitingHead)
     1386                            pEntry->pbDataReplace = (uint8_t *)RTMemPageAlloc(pEntry->cbData);
     1387
     1388                        /* If we are out of memory or have waiting segments
     1389                         * defer the write. */
     1390                        if (!pEntry->pbDataReplace || pEntry->pWaitingHead)
    13471391                        {
    1348                             PPDMACFILETASKSEG pSeg = (PPDMACFILETASKSEG)RTMemAllocZ(sizeof(PDMACFILETASKSEG));
    1349 
    1350                             pSeg->pTask      = pTask;
    1351                             pSeg->uBufOffset = OffDiff;
    1352                             pSeg->cbTransfer = RT_MIN(cbToWrite, cbSegLeft);
    1353                             pSeg->pvBuf      = pbSegBuf;
    1354                             pSeg->fWrite     = true;
    1355 
    1356                             ADVANCE_SEGMENT_BUFFER(pSeg->cbTransfer);
    1357 
    1358                             pdmacFileEpCacheEntryAddWaitingSegment(pEntry, pSeg);
    1359 
    1360                             off       += pSeg->cbTransfer;
    1361                             OffDiff   += pSeg->cbTransfer;
    1362                             cbToWrite -= pSeg->cbTransfer;
     1392                            /* The data isn't written to the file yet */
     1393                            while (cbToWrite)
     1394                            {
     1395                                PPDMACFILETASKSEG pSeg = (PPDMACFILETASKSEG)RTMemAllocZ(sizeof(PDMACFILETASKSEG));
     1396
     1397                                pSeg->pTask      = pTask;
     1398                                pSeg->uBufOffset = OffDiff;
     1399                                pSeg->cbTransfer = RT_MIN(cbToWrite, cbSegLeft);
     1400                                pSeg->pvBuf      = pbSegBuf;
     1401                                pSeg->fWrite     = true;
     1402
     1403                                ADVANCE_SEGMENT_BUFFER(pSeg->cbTransfer);
     1404
     1405                                pdmacFileEpCacheEntryAddWaitingSegment(pEntry, pSeg);
     1406
     1407                                off       += pSeg->cbTransfer;
     1408                                OffDiff   += pSeg->cbTransfer;
     1409                                cbToWrite -= pSeg->cbTransfer;
     1410                            }
     1411                            STAM_COUNTER_INC(&pEndpointCache->StatWriteDeferred);
    13631412                        }
    1364                         STAM_COUNTER_INC(&pEndpointCache->StatWriteDeferred);
     1413                        else
     1414                        {
     1415                            LogFlow(("Deprecating buffer for entry %#p\n", pEntry));
     1416                            pEntry->fFlags |= PDMACFILECACHE_ENTRY_IS_DEPRECATED;
     1417
     1418#if 1
     1419                            /* Copy the data before the update. */
     1420                            if (OffDiff)
     1421                                memcpy(pEntry->pbDataReplace, pEntry->pbData, OffDiff);
     1422
     1423                            /* Copy data behind the update. */
     1424                            if ((pEntry->cbData - OffDiff - cbToWrite) > 0)
     1425                                memcpy(pEntry->pbDataReplace + OffDiff + cbToWrite,
     1426                                       pEntry->pbData + OffDiff + cbToWrite,
     1427                                       (pEntry->cbData - OffDiff - cbToWrite));
     1428#else
     1429                            /* A safer method but probably slower. */
     1430                            memcpy(pEntry->pbDataReplace, pEntry->pbData, pEntry->cbData);
     1431#endif
     1432
     1433                            /* Update the data from the write. */
     1434                            while (cbToWrite)
     1435                            {
     1436                                size_t cbCopy = RT_MIN(cbSegLeft, cbToWrite);
     1437
     1438                                memcpy(pEntry->pbDataReplace + OffDiff, pbSegBuf, cbCopy);
     1439
     1440                                ADVANCE_SEGMENT_BUFFER(cbCopy);
     1441
     1442                                cbToWrite-= cbCopy;
     1443                                off      += cbCopy;
     1444                                OffDiff  += cbCopy;
     1445                                ASMAtomicSubS32(&pTask->cbTransferLeft, cbCopy);
     1446                            }
     1447
     1448                            /* We are done here. A new write is initiated if the current request completes. */
     1449                        }
     1450
    13651451                        RTSemRWReleaseWrite(pEndpointCache->SemRWEntries);
    13661452                    }
    13671453                    else
    13681454                    {
    1369                         /* Write as much as we can into the entry and update the file. */
    1370                         while (cbToWrite)
     1455                        /*
     1456                         * Check if a read is in progress for this entry.
     1457                         * We have to defer processing in that case.
     1458                         */
     1459                        if(pdmacFileEpCacheEntryFlagIsSetClearAcquireLock(pEndpointCache, pEntry,
     1460                                                                          PDMACFILECACHE_ENTRY_IO_IN_PROGRESS,
     1461                                                                          0))
    13711462                        {
    1372                             size_t cbCopy = RT_MIN(cbSegLeft, cbToWrite);
    1373 
    1374                             memcpy(pEntry->pbData + OffDiff, pbSegBuf, cbCopy);
    1375 
    1376                             ADVANCE_SEGMENT_BUFFER(cbCopy);
    1377 
    1378                             cbToWrite-= cbCopy;
    1379                             off      += cbCopy;
    1380                             OffDiff  += cbCopy;
    1381                             ASMAtomicSubS32(&pTask->cbTransferLeft, cbCopy);
     1463                            while (cbToWrite)
     1464                            {
     1465                                PPDMACFILETASKSEG pSeg = (PPDMACFILETASKSEG)RTMemAllocZ(sizeof(PDMACFILETASKSEG));
     1466
     1467                                pSeg->pTask      = pTask;
     1468                                pSeg->uBufOffset = OffDiff;
     1469                                pSeg->cbTransfer = RT_MIN(cbToWrite, cbSegLeft);
     1470                                pSeg->pvBuf      = pbSegBuf;
     1471                                pSeg->fWrite     = true;
     1472
     1473                                ADVANCE_SEGMENT_BUFFER(pSeg->cbTransfer);
     1474
     1475                                pdmacFileEpCacheEntryAddWaitingSegment(pEntry, pSeg);
     1476
     1477                                off       += pSeg->cbTransfer;
     1478                                OffDiff   += pSeg->cbTransfer;
     1479                                cbToWrite -= pSeg->cbTransfer;
     1480                            }
     1481                            STAM_COUNTER_INC(&pEndpointCache->StatWriteDeferred);
     1482                            RTSemRWReleaseWrite(pEndpointCache->SemRWEntries);
    13821483                        }
    1383 
    1384                         pEntry->fFlags |= PDMACFILECACHE_ENTRY_IS_DIRTY;
    1385                         pdmacFileCacheWriteToEndpoint(pEntry);
     1484                        else
     1485                        {
     1486                            /* Write as much as we can into the entry and update the file. */
     1487                            while (cbToWrite)
     1488                            {
     1489                                size_t cbCopy = RT_MIN(cbSegLeft, cbToWrite);
     1490
     1491                                memcpy(pEntry->pbData + OffDiff, pbSegBuf, cbCopy);
     1492
     1493                                ADVANCE_SEGMENT_BUFFER(cbCopy);
     1494
     1495                                cbToWrite-= cbCopy;
     1496                                off      += cbCopy;
     1497                                OffDiff  += cbCopy;
     1498                                ASMAtomicSubS32(&pTask->cbTransferLeft, cbCopy);
     1499                            }
     1500
     1501                            pEntry->fFlags |= PDMACFILECACHE_ENTRY_IS_DIRTY;
     1502                            pdmacFileCacheWriteToEndpoint(pEntry);
     1503                        }
    13861504                    }
     1505
     1506                    /* Move this entry to the top position */
     1507                    RTCritSectEnter(&pCache->CritSect);
     1508                    pdmacFileCacheEntryAddToList(&pCache->LruFrequentlyUsed, pEntry);
     1509                    RTCritSectLeave(&pCache->CritSect);
    13871510                }
    1388 
    1389                 /* Move this entry to the top position */
    1390                 RTCritSectEnter(&pCache->CritSect);
    1391                 pdmacFileCacheEntryAddToList(&pCache->LruFrequentlyUsed, pEntry);
    1392                 RTCritSectLeave(&pCache->CritSect);
    13931511            }
    13941512            else

  • trunk/src/VBox/VMM/PDMAsyncCompletionFileInternal.h

    r24278 r24356  
    229229    /** Pointer to the memory containing the data. */
    230230    uint8_t                        *pbData;
     231    /** Pointer to the buffer replacing the current one
     232     * if the deprecated flag is set. */
     233    uint8_t                        *pbDataReplace;
    231234    /** Head of list of tasks waiting for this one to finish. */
    232235    PPDMACFILETASKSEG               pWaitingHead;
    … …  
    237240#define PDMACFILECACHE_ENTRY_IO_IN_PROGRESS RT_BIT(0)
    238241/** Entry is locked and thus not evictable. */
    239 #define PDMACFILECACHE_ENTRY_LOCKED   RT_BIT(1)
     242#define PDMACFILECACHE_ENTRY_LOCKED         RT_BIT(1)
    240243/** Entry is dirty */
    241 #define PDMACFILECACHE_ENTRY_IS_DIRTY RT_BIT(2)
     244#define PDMACFILECACHE_ENTRY_IS_DIRTY       RT_BIT(2)
     245/** The current buffer used for the entry is deprecated.
     246 * The new one is available and will be replaced as soon as the file update
     247 * completed.
     248 */
     249#define PDMACFILECACHE_ENTRY_IS_DEPRECATED  RT_BIT(3)
    242250/** Entry is not evictable. */
    243251#define PDMACFILECACHE_NOT_EVICTABLE  (PDMACFILECACHE_ENTRY_LOCKED | PDMACFILECACHE_IO_IN_PROGRESS)
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette