VirtualBox

Changeset 638 in vbox


Ignore:
Timestamp:
Feb 5, 2007 2:18:05 PM (18 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
18267
Message:

Reduced time spent inside locks.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Network/DevPCNet.cpp

    r605 r638  
    6262#include <VBox/pgm.h>
    6363#include <VBox/stam.h>
     64#include <VBox/vm.h> /* for VM_IS_EMT */
    6465#include <iprt/asm.h>
    6566#include <iprt/assert.h>
    … …  
    239240    RTTHREAD                            hSendThread;
    240241#endif
    241     uint32_t                            fPendingSend;
    242242
    243243    /** Access critical section. */
    … …  
    307307    STAMCOUNTER                         StatXmitSync;
    308308    STAMCOUNTER                         StatXmitAsync;
     309    STAMCOUNTER                         StatXmitInTxThread;
    309310    STAMPROFILE                         StatXmitQueueAsync;
    310311#endif /* VBOX_WITH_STATISTICS */
    … …  
    10011002
    10021003
    1003 #ifdef IN_RING3
    1004 static DECLCALLBACK(void) pcnetXmitSendPackets(PCNetState *pData);
    1005 #endif
    1006 
    1007 /**
    1008  * Wrapper for PDMCritSectEnter
    1009  */
    1010 #define PCNetCritSectEnter(pCritSect, rcBusy) \
    1011     PDMCritSectEnter(pCritSect, rcBusy);
    1012 
    1013 /**
    1014  * Wrapper for PDMCritSectLeave
    1015  *
    1016  * Generic, but primarily intended for the receive thread that has grabbed the critical section
    1017  */
    1018 #ifdef IN_RING3
    1019 #define PCNetCritSectLeave(pData)            \
    1020     if (ASMAtomicCmpXchgU32(&pData->fPendingSend, 0, 1))             \
    1021     {                                                                \
    1022         STAM_COUNTER_INC(&pData->StatDeferredXmit);                  \
    1023         pcnetXmitSendPackets(pData);                                 \
    1024     }                                                                \
    1025     PDMCritSectLeave(&pData->CritSect)
    1026 #else
    1027 #define PCNetCritSectLeave(pData)            \
    1028     PDMCritSectLeave(&pData->CritSect)
    1029 #endif /* IN_RING3 */
    1030 
    1031 /**
    1032  * Wrapper for PDMR3CritSectTryEnter
    1033  */
    1034 #define PCNetCritSectTryEnter(pData) \
    1035     PDMR3CritSectTryEnter(&pData->CritSect)
    1036 
    10371004#ifdef PCNET_NO_POLLING
    10381005# ifndef IN_RING3
    … …  
    10681035            uint32_t offsetTDRA = (GCPhysFault - pData->GCTDRA);
    10691036
    1070             int rc = PCNetCritSectEnter(&pData->CritSect, VERR_SEM_BUSY);
     1037            int rc = PDMCritSectEnter(&pData->CritSect, VERR_SEM_BUSY);
    10711038            if (VBOX_SUCCESS(rc))
    10721039            {
    … …  
    10771044                pcnetUpdateIrq(pData);
    10781045
    1079                 PCNetCritSectLeave(pData);
     1046                PDMCritSectLeave(&pData->CritSect);
    10801047                return VINF_SUCCESS;
    10811048            }
    … …  
    11351102           )
    11361103        {
    1137             int rc = PCNetCritSectEnter(&pData->CritSect, VERR_SEM_BUSY);
     1104            int rc = PDMCritSectEnter(&pData->CritSect, VERR_SEM_BUSY);
    11381105            AssertReleaseRC(rc);
    11391106            /* Check if we can do something now */
    11401107            pcnetPollRxTx(pData);
    11411108            pcnetUpdateIrq(pData);
    1142             PCNetCritSectLeave(pData);
     1109            PDMCritSectLeave(&pData->CritSect);
    11431110        }
    11441111    }
    … …  
    18571824    int         rc;
    18581825
     1826    /** @note We must only access the queued transmit packets from EMT. Below we assume we don't need to grab the critical section while accessing
     1827      *       this data.
     1828      */
     1829    Assert(VM_IS_EMT(PDMDevHlpGetVM(PCNETSTATE_2_DEVINS(pData))));
     1830
     1831    /* Return immediately if there's nothing to do. (grabbing the critical section can be expensive) */
     1832    if (RT_UNLIKELY(pData->iFrame == 0))
     1833    {
     1834        STAM_COUNTER_INC(&pData->aStatFlushCounts[pData->iFrame]);
     1835        return;
     1836    }
     1837
    18591838    STAM_PROFILE_START(&pData->StatXmitQueue, a);
    18601839    STAM_COUNTER_INC(&pData->aStatFlushCounts[pData->iFrame]);
    1861     rc = PCNetCritSectTryEnter(pData);
    1862     if (rc != VINF_SUCCESS)
    1863     {
    1864         /* Somebody else grabbed the critical section (most likely the receive thread) */
    1865         Assert(!pData->fPendingSend);
    1866 
    1867         ASMAtomicCmpXchgU32(&pData->fPendingSend, 1, 0);
    1868 
    1869         /* If we can't get the critsect now, then whoever owns it will send the packets for us (see PCNetCritSectLeave) */
    1870         rc = PCNetCritSectTryEnter(pData);
    1871         if (rc != VINF_SUCCESS)
    1872         {
    1873             STAM_COUNTER_INC(&pData->StatDeferredXmitPending);           
    1874             STAM_COUNTER_DEC(&pData->aStatFlushCounts[pData->iFrame]);
    1875             STAM_PROFILE_STOP(&pData->StatXmitQueue, a);
    1876             return;
    1877         }
    1878 
    1879         /* We were too late (or got rescheduled in an unfortunate way (iFrame=0), so let's just continue. */
    1880         pData->fPendingSend = 0;
    1881     }
    1882 
    1883     AssertReleaseRC(rc);
    18841840    Log(("#%d pcnetXmitQueueConsumer: iFrame=%d\n", PCNETSTATE_2_DEVINS(pData)->iInstance, pData->iFrame));
    18851841
    … …  
    19471903    if (pData->iFrame)
    19481904    {
     1905        /** @note this part needs to be protected; perhaps we can change the code to drop this requirement. */
     1906        rc = PDMCritSectEnter(&pData->CritSect, VERR_PERMISSION_DENIED);
     1907        AssertReleaseRC(rc);
     1908
    19491909        /* Update TXSTRT and TINT. */
    19501910        pData->aCSR[4] |=  0x0004;       /* set TXSTRT */
    19511911        pData->aCSR[0] |= 0x0200;    /* set TINT */
    19521912        pcnetUpdateIrq(pData);
     1913
     1914        PDMCritSectLeave(&pData->CritSect);
    19531915    }
    19541916#endif
    … …  
    19621924    pData->Led.Actual.s.fWriting = 0;
    19631925
    1964     PCNetCritSectLeave(pData);
    19651926    STAM_PROFILE_STOP(&pData->StatXmitQueue, a);
    19661927}
    … …  
    20111972DECLINLINE(void) pcnetXmitFlushFrames(PCNetState *pData)
    20121973{
     1974    Assert(VM_IS_EMT(PDMDevHlpGetVM(PCNETSTATE_2_DEVINS(pData))));
    20131975    if (pData->iFrame)
    20141976    {
    … …  
    20392001{
    20402002    const uint32_t iFrame = pData->iFrame;
     2003
     2004    Assert(VM_IS_EMT(PDMDevHlpGetVM(PCNETSTATE_2_DEVINS(pData))));
     2005
    20412006    pData->aFrames[iFrame].cb = -1;
    20422007}
    … …  
    20492014{
    20502015    const uint32_t iFrame = pData->iFrame;
     2016
     2017    Assert(VM_IS_EMT(PDMDevHlpGetVM(PCNETSTATE_2_DEVINS(pData))));
     2018
    20512019    if (    fForceFlush
    20522020        ||  cb > sizeof(pData->abFrameBuf) - pData->aFrames[iFrame].off)
    … …  
    20642032{
    20652033    const uint32_t iFrame = pData->iFrame;
     2034
     2035    Assert(VM_IS_EMT(PDMDevHlpGetVM(PCNETSTATE_2_DEVINS(pData))));
     2036
    20662037    pData->aFrames[iFrame].pvR3 = pv;
    20672038    pData->aFrames[iFrame].cb   = cbFrame;
    … …  
    20762047{
    20772048    const uint32_t iFrame = pData->iFrame;
     2049
     2050    Assert(VM_IS_EMT(PDMDevHlpGetVM(PCNETSTATE_2_DEVINS(pData))));
     2051
    20782052    PDMDevHlpPhysRead(pData->CTXSUFF(pDevIns), GCPhysFrame,
    20792053                      &pData->abFrameBuf[pData->aFrames[iFrame].off],
    … …  
    20892063{
    20902064    const uint32_t iFrame = pData->iFrame;
     2065
     2066    Assert(VM_IS_EMT(PDMDevHlpGetVM(PCNETSTATE_2_DEVINS(pData))));
     2067
    20912068    PDMDevHlpPhysRead(pData->CTXSUFF(pDevIns), GCPhysFrame,
    20922069                      &pData->abFrameBuf[pData->aFrames[iFrame].off + pData->aFrames[iFrame].cb],
    … …  
    21032080{
    21042081    const uint32_t iFrame = ++pData->iFrame;
     2082
     2083    Assert(VM_IS_EMT(PDMDevHlpGetVM(PCNETSTATE_2_DEVINS(pData))));
     2084
    21052085    if (iFrame == ELEMENTS(pData->aFrames))
    21062086        pcnetXmitFlushFrames(pData);
    … …  
    21372117{
    21382118    Assert(pData->iFrame == 0);
     2119    Assert(VM_IS_EMT(PDMDevHlpGetVM(PCNETSTATE_2_DEVINS(pData))));
     2120
    21392121    pData->Led.Asserted.s.fReading = pData->Led.Actual.s.fReading = 1;
    21402122    if (HOST_IS_OWNER(CSR_CRST(pData)))
    … …  
    21552137     * recursion when flushing a queue.
    21562138     */
    2157     if (pData->fTransmitting)
     2139    if (    pData->fTransmitting
     2140        ||  !VM_IS_EMT(PDMDevHlpGetVM(PCNETSTATE_2_DEVINS(pData))))
    21582141        return;
     2142
     2143    Assert(VM_IS_EMT(PDMDevHlpGetVM(PCNETSTATE_2_DEVINS(pData))));
    21592144
    21602145    if (RT_UNLIKELY(!CSR_TXON(pData)))
    … …  
    31233108    {
    31243109        STAM_PROFILE_ADV_START(&pData->StatAPROMRead, a);
    3125         rc = PCNetCritSectEnter(&pData->CritSect, VINF_IOM_HC_IOPORT_WRITE);
     3110        rc = PDMCritSectEnter(&pData->CritSect, VINF_IOM_HC_IOPORT_WRITE);
    31263111        if (rc == VINF_SUCCESS)
    31273112        {
    31283113            *pu32 = pcnetAPROMReadU8(pData, Port);
    3129             PCNetCritSectLeave(pData);
     3114            PDMCritSectLeave(&pData->CritSect);
    31303115        }
    31313116        STAM_PROFILE_ADV_STOP(&pData->StatAPROMRead, a);
    … …  
    31593144    {
    31603145        STAM_PROFILE_ADV_START(&pData->StatAPROMWrite, a);
    3161         rc = PCNetCritSectEnter(&pData->CritSect, VINF_IOM_HC_IOPORT_WRITE);
     3146        rc = PDMCritSectEnter(&pData->CritSect, VINF_IOM_HC_IOPORT_WRITE);
    31623147        if (rc == VINF_SUCCESS)
    31633148        {
    31643149            pcnetAPROMWriteU8(pData, Port, u32);
    3165             PCNetCritSectLeave(pData);
     3150            PDMCritSectLeave(&pData->CritSect);
    31663151        }
    31673152        STAM_PROFILE_ADV_STOP(&pData->StatAPROMWrite, a);
    … …  
    31963181
    31973182    STAM_PROFILE_ADV_START(&pData->CTXSUFF(StatIORead), a);
    3198     rc = PCNetCritSectEnter(&pData->CritSect, VINF_IOM_HC_IOPORT_READ);
     3183    rc = PDMCritSectEnter(&pData->CritSect, VINF_IOM_HC_IOPORT_READ);
    31993184    if (rc == VINF_SUCCESS)
    32003185    {
    … …  
    32073192                break;
    32083193        }
    3209         PCNetCritSectLeave(pData);
     3194        PDMCritSectLeave(&pData->CritSect);
    32103195    }
    32113196    STAM_PROFILE_ADV_STOP(&pData->CTXSUFF(StatIORead), a);
    … …  
    32343219
    32353220    STAM_PROFILE_ADV_START(&pData->CTXSUFF(StatIOWrite), a);
    3236     rc = PCNetCritSectEnter(&pData->CritSect, VINF_IOM_HC_IOPORT_WRITE);
     3221    rc = PDMCritSectEnter(&pData->CritSect, VINF_IOM_HC_IOPORT_WRITE);
    32373222    if (rc == VINF_SUCCESS)
    32383223    {
    … …  
    32463231                break;
    32473232        }
    3248         PCNetCritSectLeave(pData);
     3233        PDMCritSectLeave(&pData->CritSect);
    32493234    }
    32503235    STAM_PROFILE_ADV_STOP(&pData->CTXSUFF(StatIOWrite), a);
    … …  
    32783263    {
    32793264        STAM_PROFILE_ADV_START(&pData->CTXSUFF(StatMMIORead), a);
    3280         rc = PCNetCritSectEnter(&pData->CritSect, VINF_IOM_HC_MMIO_READ);
     3265        rc = PDMCritSectEnter(&pData->CritSect, VINF_IOM_HC_MMIO_READ);
    32813266        if (rc == VINF_SUCCESS)
    32823267        {
    … …  
    32913276                    break;
    32923277            }
    3293             PCNetCritSectLeave(pData);
     3278            PDMCritSectLeave(&pData->CritSect);
    32943279        }
    32953280        STAM_PROFILE_ADV_STOP(&pData->CTXSUFF(StatMMIORead), a);
    … …  
    33273312    {
    33283313        STAM_PROFILE_ADV_START(&pData->CTXSUFF(StatMMIOWrite), a);
    3329         rc = PCNetCritSectEnter(&pData->CritSect, VINF_IOM_HC_MMIO_WRITE);
     3314        rc = PDMCritSectEnter(&pData->CritSect, VINF_IOM_HC_MMIO_WRITE);
    33303315        if (rc == VINF_SUCCESS)
    33313316        {
    … …  
    33403325                    break;
    33413326            }
    3342             PCNetCritSectLeave(pData);
     3327            PDMCritSectLeave(&pData->CritSect);
    33433328        }
    33443329        // else rc == VINF_IOM_HC_MMIO_WRITE => handle in ring3
    … …  
    33663351
    33673352    STAM_PROFILE_ADV_START(&pData->StatTimer, a);
    3368     rc = PCNetCritSectEnter(&pData->CritSect, VERR_PERMISSION_DENIED);
     3353    rc = PDMCritSectEnter(&pData->CritSect, VERR_PERMISSION_DENIED);
    33693354    AssertReleaseRC(rc);
    33703355
    33713356    pcnetPollTimer(pData);
    33723357
    3373     PCNetCritSectLeave(pData);
     3358    PDMCritSectLeave(&pData->CritSect);
    33743359    STAM_PROFILE_ADV_STOP(&pData->StatTimer, a);
    33753360}
    … …  
    33893374{
    33903375    PCNetState *pData = PDMINS2DATA(pDevIns, PCNetState *);
    3391     int         rc = PCNetCritSectEnter(&pData->CritSect, VERR_PERMISSION_DENIED);
     3376    int         rc = PDMCritSectEnter(&pData->CritSect, VERR_PERMISSION_DENIED);
    33923377    AssertReleaseRC(rc);
    33933378
    … …  
    34123397             pDevIns->iInstance, pData->cLinkDownReported));
    34133398
    3414     PCNetCritSectLeave(pData);
     3399    PDMCritSectLeave(&pData->CritSect);
    34153400}
    34163401
    … …  
    35383523                    pData->fAm79C973 ? "Am79C973" : "Am79C970A", pData->fGCEnabled ? " GC" : "", pData->fR0Enabled ? " R0" : "");
    35393524
    3540     PCNetCritSectEnter(&pData->CritSect, VERR_INTERNAL_ERROR); /* Take it here so we know why we're hanging... */
     3525    PDMCritSectEnter(&pData->CritSect, VERR_INTERNAL_ERROR); /* Take it here so we know why we're hanging... */
    35413526
    35423527    pHlp->pfnPrintf(pHlp,
    … …  
    37303715    }
    37313716
    3732     PCNetCritSectLeave(pData);
     3717    PDMCritSectLeave(&pData->CritSect);
    37333718}
    37343719
    … …  
    38773862    PCNetState *pData = INETWORKPORT_2_DATA(pInterface);
    38783863
    3879     rc = PCNetCritSectEnter(&pData->CritSect, VERR_PERMISSION_DENIED);
     3864    rc = PDMCritSectEnter(&pData->CritSect, VERR_PERMISSION_DENIED);
    38803865    AssertReleaseRC(rc);
    38813866
    38823867    cb = pcnetCanReceiveNoSync(pData);
    38833868
    3884     PCNetCritSectLeave(pData);
     3869    PDMCritSectLeave(&pData->CritSect);
    38853870    return cb;
    38863871}
    … …  
    39023887
    39033888    STAM_PROFILE_ADV_START(&pData->StatReceive, a);
    3904     rc = PCNetCritSectEnter(&pData->CritSect, VERR_PERMISSION_DENIED);
     3889    rc = PDMCritSectEnter(&pData->CritSect, VERR_PERMISSION_DENIED);
    39053890    AssertReleaseRC(rc);
    39063891
    … …  
    39103895    pData->Led.Actual.s.fReading = 0;
    39113896
    3912     PCNetCritSectLeave(pData);
     3897    PDMCritSectLeave(&pData->CritSect);
    39133898    STAM_PROFILE_ADV_STOP(&pData->StatReceive, a);
    39143899
    … …  
    43724357    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatXmitSync,           STAMTYPE_COUNTER,  STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Nr of sync packet xmits", "/Devices/PCNet%d/Xmit/Sync", iInstance);
    43734358    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatXmitAsync,          STAMTYPE_COUNTER,  STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Nr of async packet xmits", "/Devices/PCNet%d/Xmit/ASync", iInstance);
    4374 
     4359    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatXmitInTxThread,     STAMTYPE_COUNTER,  STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Nr of packet xmits in rx thread", "/Devices/PCNet%d/Xmit/RxThread", iInstance);
    43754360
    43764361    unsigned i;
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