VirtualBox

Changeset 59036 in vbox for trunk/src/VBox/Runtime/generic


Ignore:
Timestamp:
Dec 7, 2015 5:49:30 PM (9 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
104580
Message:

IPRT,VMMR0: Added trace points to both the IPRT critical section types.

Location:
trunk/src/VBox/Runtime/generic
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Runtime/generic/critsect-generic.cpp

    r57358 r59036  
    4141#include "internal/strict.h"
    4242
     43/* Two issues here, (1) the tracepoint generator uses IPRT, and (2) only one .d
     44   file per module. */
     45#ifdef IPRT_WITH_DTRACE
     46# include IPRT_DTRACE_INCLUDE
     47# define IPRT_CRITSECT_ENTERED  RT_CONCAT(IPRT_WITH_DTRACE,IPRT_CRITSECT_ENTERED)
     48# define IPRT_CRITSECT_LEAVING  RT_CONCAT(IPRT_WITH_DTRACE,IPRT_CRITSECT_LEAVING)
     49# define IPRT_CRITSECT_BUSY     RT_CONCAT(IPRT_WITH_DTRACE,IPRT_CRITSECT_BUSY)
     50# define IPRT_CRITSECT_WAITING  RT_CONCAT(IPRT_WITH_DTRACE,IPRT_CRITSECT_WAITING)
     51#else
     52# define IPRT_CRITSECT_ENTERED(a_pvCritSect, a_pszName, a_cLockers, a_cNestings)            do {} while (0)
     53# define IPRT_CRITSECT_LEAVING(a_pvCritSect, a_pszName, a_cLockers, a_cNestings)            do {} while (0)
     54# define IPRT_CRITSECT_BUSY(   a_pvCritSect, a_pszName, a_cLockers, a_pvNativeOwnerThread)  do {} while (0)
     55# define IPRT_CRITSECT_WAITING(a_pvCritSect, a_pszName, a_cLockers, a_pvNativeOwnerThread)  do {} while (0)
     56#endif
     57
     58
    4359
    4460RTDECL(int) RTCritSectInit(PRTCRITSECT pCritSect)
    … …  
    165181                    return rc9;
    166182#endif
    167                 ASMAtomicIncS32(&pCritSect->cLockers);
     183                int32_t cLockers = ASMAtomicIncS32(&pCritSect->cLockers); NOREF(cLockers);
    168184                pCritSect->cNestings++;
     185                IPRT_CRITSECT_ENTERED(pCritSect, NULL, cLockers, pCritSect->cNestings);
    169186                return VINF_SUCCESS;
    170187            }
    … …  
    172189            return VERR_SEM_NESTED;
    173190        }
     191        IPRT_CRITSECT_BUSY(pCritSect, NULL, pCritSect->cLockers, (void *)pCritSect->NativeThreadOwner);
    174192        return VERR_SEM_BUSY;
    175193    }
    … …  
    183201    RTLockValidatorRecExclSetOwner(pCritSect->pValidatorRec, NIL_RTTHREAD, pSrcPos, true);
    184202#endif
     203    IPRT_CRITSECT_ENTERED(pCritSect, NULL, 0, 1);
    185204
    186205    return VINF_SUCCESS;
    … …  
    245264     * This becomes 0 when the section is free.
    246265     */
    247     if (ASMAtomicIncS32(&pCritSect->cLockers) > 0)
     266    int32_t cLockers = ASMAtomicIncS32(&pCritSect->cLockers);
     267    if (cLockers > 0)
    248268    {
    249269        /*
    … …  
    263283#endif
    264284                pCritSect->cNestings++;
     285                IPRT_CRITSECT_ENTERED(pCritSect, NULL, cLockers, pCritSect->cNestings);
    265286                return VINF_SUCCESS;
    266287            }
    … …  
    274295         * Wait for the current owner to release it.
    275296         */
     297        IPRT_CRITSECT_WAITING(pCritSect, NULL, cLockers, (void *)pCritSect->NativeThreadOwner);
    276298#ifndef RTCRITSECT_STRICT
    277299        RTTHREAD hThreadSelf = RTThreadSelf();
    … …  
    313335    RTLockValidatorRecExclSetOwner(pCritSect->pValidatorRec, hThreadSelf, pSrcPos, true);
    314336#endif
     337    IPRT_CRITSECT_ENTERED(pCritSect, NULL, 0, 1);
    315338
    316339    return VINF_SUCCESS;
    … …  
    369392     * Decrement nestings, if <= 0 when we'll release the critsec.
    370393     */
    371     pCritSect->cNestings--;
    372     if (pCritSect->cNestings > 0)
     394    uint32_t cNestings = --pCritSect->cNestings;
     395    IPRT_CRITSECT_LEAVING(pCritSect, NULL, ASMAtomicUoReadS32(&pCritSect->cLockers) - 1, cNestings);
     396    if (cNestings > 0)
    373397        ASMAtomicDecS32(&pCritSect->cLockers);
    374398    else

  • trunk/src/VBox/Runtime/generic/critsectrw-generic.cpp

    r58829 r59036  
    4545#include "internal/strict.h"
    4646
     47/* Two issues here, (1) the tracepoint generator uses IPRT, and (2) only one .d
     48   file per module. */
     49#ifdef IPRT_WITH_DTRACE
     50# include IPRT_DTRACE_INCLUDE
     51# define IPRT_CRITSECTRW_EXCL_ENTERED           RT_CONCAT(IPRT_WITH_DTRACE,IPRT_CRITSECTRW_EXCL_ENTERED)
     52# define IPRT_CRITSECTRW_EXCL_ENTERED_ENABLED   RT_CONCAT(IPRT_WITH_DTRACE,IPRT_CRITSECTRW_EXCL_ENTERED_ENABLED)
     53# define IPRT_CRITSECTRW_EXCL_LEAVING           RT_CONCAT(IPRT_WITH_DTRACE,IPRT_CRITSECTRW_EXCL_LEAVING)
     54# define IPRT_CRITSECTRW_EXCL_LEAVING_ENABLED   RT_CONCAT(IPRT_WITH_DTRACE,IPRT_CRITSECTRW_EXCL_LEAVING_ENABLED)
     55# define IPRT_CRITSECTRW_EXCL_BUSY              RT_CONCAT(IPRT_WITH_DTRACE,IPRT_CRITSECTRW_EXCL_BUSY)
     56# define IPRT_CRITSECTRW_EXCL_WAITING           RT_CONCAT(IPRT_WITH_DTRACE,IPRT_CRITSECTRW_EXCL_WAITING)
     57# define IPRT_CRITSECTRW_EXCL_ENTERED_SHARED    RT_CONCAT(IPRT_WITH_DTRACE,IPRT_CRITSECTRW_EXCL_ENTERED_SHARED)
     58# define IPRT_CRITSECTRW_EXCL_LEAVING_SHARED    RT_CONCAT(IPRT_WITH_DTRACE,IPRT_CRITSECTRW_EXCL_LEAVING_SHARED)
     59# define IPRT_CRITSECTRW_SHARED_ENTERED         RT_CONCAT(IPRT_WITH_DTRACE,IPRT_CRITSECTRW_SHARED_ENTERED)
     60# define IPRT_CRITSECTRW_SHARED_LEAVING         RT_CONCAT(IPRT_WITH_DTRACE,IPRT_CRITSECTRW_SHARED_LEAVING)
     61# define IPRT_CRITSECTRW_SHARED_BUSY            RT_CONCAT(IPRT_WITH_DTRACE,IPRT_CRITSECTRW_SHARED_BUSY)
     62# define IPRT_CRITSECTRW_SHARED_WAITING         RT_CONCAT(IPRT_WITH_DTRACE,IPRT_CRITSECTRW_SHARED_WAITING)
     63#else
     64# define IPRT_CRITSECTRW_EXCL_ENTERED(a_pvCritSect, a_pszName, a_cNestings, a_cWaitingReaders, a_cWriters) do {} while (0)
     65# define IPRT_CRITSECTRW_EXCL_ENTERED_ENABLED() (false)
     66# define IPRT_CRITSECTRW_EXCL_LEAVING(a_pvCritSect, a_pszName, a_cNestings, a_cWaitingReaders, a_cWriters) do {} while (0)
     67# define IPRT_CRITSECTRW_EXCL_LEAVING_ENABLED() (false)
     68# define IPRT_CRITSECTRW_EXCL_BUSY(   a_pvCritSect, a_pszName, a_fWriteMode, a_cWaitingReaders, a_cReaders, cWriters, a_pvNativeOwnerThread) do {} while (0)
     69# define IPRT_CRITSECTRW_EXCL_WAITING(a_pvCritSect, a_pszName, a_fWriteMode, a_cWaitingReaders, a_cReaders, cWriters, a_pvNativeOwnerThread) do {} while (0)
     70# define IPRT_CRITSECTRW_EXCL_ENTERED_SHARED(a_pvCritSect, a_pszName, a_cNestings, a_cWaitingReaders, a_cWriters) do {} while (0)
     71# define IPRT_CRITSECTRW_EXCL_LEAVING_SHARED(a_pvCritSect, a_pszName, a_cNestings, a_cWaitingReaders, a_cWriters) do {} while (0)
     72# define IPRT_CRITSECTRW_SHARED_ENTERED(a_pvCritSect, a_pszName, a_cReaders, a_cWaitingWriters)     do {} while (0)
     73# define IPRT_CRITSECTRW_SHARED_LEAVING(a_pvCritSect, a_pszName, a_cReaders, a_cWaitingWriters)     do {} while (0)
     74# define IPRT_CRITSECTRW_SHARED_BUSY(   a_pvCritSect, a_pszName, a_pvNativeOwnerThread, a_cWaitingReaders, a_cWriters) do {} while (0)
     75# define IPRT_CRITSECTRW_SHARED_WAITING(a_pvCritSect, a_pszName, a_pvNativeOwnerThread, a_cWaitingReaders, a_cWriters) do {} while (0)
     76#endif
     77
    4778
    4879
    … …  
    242273#endif
    243274                Assert(pThis->cWriterReads < UINT32_MAX / 2);
    244                 ASMAtomicIncU32(&pThis->cWriterReads);
     275                uint32_t const cReads = ASMAtomicIncU32(&pThis->cWriterReads); NOREF(cReads);
     276                IPRT_CRITSECTRW_EXCL_ENTERED_SHARED(pThis, NULL,
     277                                                    cReads + pThis->cWriteRecursions,
     278                                                    (uint32_t)((u64State & RTCSRW_WAIT_CNT_RD_MASK) >> RTCSRW_WAIT_CNT_RD_SHIFT),
     279                                                    (uint32_t)((u64State & RTCSRW_CNT_WR_MASK) >> RTCSRW_CNT_WR_SHIFT));
     280
    245281                return VINF_SUCCESS; /* don't break! */
    246282            }
    … …  
    248284            /* If we're only trying, return already. */
    249285            if (fTryOnly)
     286            {
     287                IPRT_CRITSECTRW_SHARED_BUSY(pThis, NULL,
     288                                            (void *)pThis->hNativeWriter,
     289                                            (uint32_t)((u64State & RTCSRW_WAIT_CNT_RD_MASK) >> RTCSRW_WAIT_CNT_RD_SHIFT),
     290                                            (uint32_t)((u64State & RTCSRW_CNT_WR_MASK) >> RTCSRW_CNT_WR_SHIFT));
    250291                return VERR_SEM_BUSY;
     292            }
    251293
    252294            /* Add ourselves to the queue and wait for the direction to change. */
    … …  
    265307            if (ASMAtomicCmpXchgU64(&pThis->u64State, u64State, u64OldState))
    266308            {
     309                IPRT_CRITSECTRW_SHARED_WAITING(pThis, NULL,
     310                                               (void *)pThis->hNativeWriter,
     311                                               (uint32_t)((u64State & RTCSRW_WAIT_CNT_RD_MASK) >> RTCSRW_WAIT_CNT_RD_SHIFT),
     312                                               (uint32_t)((u64State & RTCSRW_CNT_WR_MASK) >> RTCSRW_CNT_WR_SHIFT));
    267313                for (uint32_t iLoop = 0; ; iLoop++)
    268314                {
    … …  
    352398    /* got it! */
    353399    Assert((ASMAtomicReadU64(&pThis->u64State) & RTCSRW_DIR_MASK) == (RTCSRW_DIR_READ << RTCSRW_DIR_SHIFT));
     400    IPRT_CRITSECTRW_SHARED_ENTERED(pThis, NULL,
     401                                   (uint32_t)((u64State & RTCSRW_CNT_RD_MASK) >> RTCSRW_CNT_RD_SHIFT),
     402                                   (uint32_t)((u64State & RTCSRW_CNT_WR_MASK) >> RTCSRW_CNT_WR_SHIFT));
    354403    return VINF_SUCCESS;
    355 
    356404}
    357405
    … …  
    423471            return rc9;
    424472#endif
     473        IPRT_CRITSECTRW_SHARED_LEAVING(pThis, NULL,
     474                                       (uint32_t)((u64State & RTCSRW_CNT_RD_MASK) >> RTCSRW_CNT_RD_SHIFT) - 1,
     475                                       (uint32_t)((u64State & RTCSRW_CNT_WR_MASK) >> RTCSRW_CNT_WR_SHIFT));
     476
    425477        for (;;)
    426478        {
    … …  
    468520            return rc;
    469521#endif
    470         ASMAtomicDecU32(&pThis->cWriterReads);
     522        uint32_t cReads = ASMAtomicDecU32(&pThis->cWriterReads); NOREF(cReads);
     523        IPRT_CRITSECTRW_EXCL_LEAVING_SHARED(pThis, NULL,
     524                                            cReads + pThis->cWriteRecursions,
     525                                            (uint32_t)((u64State & RTCSRW_WAIT_CNT_RD_MASK) >> RTCSRW_WAIT_CNT_RD_SHIFT),
     526                                            (uint32_t)((u64State & RTCSRW_CNT_WR_MASK) >> RTCSRW_CNT_WR_SHIFT));
    471527    }
    472528
    … …  
    515571#endif
    516572        Assert(pThis->cWriteRecursions < UINT32_MAX / 2);
    517         ASMAtomicIncU32(&pThis->cWriteRecursions);
     573        uint32_t cNestings = ASMAtomicIncU32(&pThis->cWriteRecursions); NOREF(cNestings);
     574
     575        if (IPRT_CRITSECTRW_EXCL_ENTERED_ENABLED())
     576        {
     577            uint64_t u64State = ASMAtomicReadU64(&pThis->u64State);
     578            IPRT_CRITSECTRW_EXCL_ENTERED(pThis, NULL, cNestings + pThis->cWriterReads,
     579                                         (uint32_t)((u64State & RTCSRW_WAIT_CNT_RD_MASK) >> RTCSRW_WAIT_CNT_RD_SHIFT),
     580                                         (uint32_t)((u64State & RTCSRW_CNT_WR_MASK) >> RTCSRW_CNT_WR_SHIFT));
     581        }
    518582        return VINF_SUCCESS;
    519583    }
    … …  
    522586     * Get cracking.
    523587     */
    524     uint64_t u64State    = ASMAtomicReadU64(&pThis->u64State);
     588    uint64_t u64State = ASMAtomicReadU64(&pThis->u64State);
    525589    uint64_t u64OldState = u64State;
    526590
    … …  
    596660                    break;
    597661            }
     662            IPRT_CRITSECTRW_EXCL_BUSY(pThis, NULL,
     663                                      (u64State & RTCSRW_DIR_MASK) == (RTCSRW_DIR_WRITE << RTCSRW_DIR_SHIFT) /*fWrite*/,
     664                                      (uint32_t)((u64State & RTCSRW_WAIT_CNT_RD_MASK) >> RTCSRW_WAIT_CNT_RD_SHIFT),
     665                                      (uint32_t)((u64State & RTCSRW_CNT_RD_MASK) >> RTCSRW_CNT_RD_SHIFT),
     666                                      (uint32_t)((u64State & RTCSRW_CNT_WR_MASK) >> RTCSRW_CNT_WR_SHIFT),
     667                                      (void *)pThis->hNativeWriter);
    598668            return VERR_SEM_BUSY;
    599669        }
    … …  
    602672         * Wait for our turn.
    603673         */
     674        IPRT_CRITSECTRW_EXCL_WAITING(pThis, NULL,
     675                                     (u64State & RTCSRW_DIR_MASK) == (RTCSRW_DIR_WRITE << RTCSRW_DIR_SHIFT) /*fWrite*/,
     676                                     (uint32_t)((u64State & RTCSRW_WAIT_CNT_RD_MASK) >> RTCSRW_WAIT_CNT_RD_SHIFT),
     677                                     (uint32_t)((u64State & RTCSRW_CNT_RD_MASK) >> RTCSRW_CNT_RD_SHIFT),
     678                                     (uint32_t)((u64State & RTCSRW_CNT_WR_MASK) >> RTCSRW_CNT_WR_SHIFT),
     679                                     (void *)pThis->hNativeWriter);
    604680        for (uint32_t iLoop = 0; ; iLoop++)
    605681        {
    … …  
    659735    RTLockValidatorRecExclSetOwner(pThis->pValidatorWrite, hThreadSelf, pSrcPos, true);
    660736#endif
     737    IPRT_CRITSECTRW_EXCL_ENTERED(pThis, NULL, 1,
     738                                 (uint32_t)((u64State & RTCSRW_WAIT_CNT_RD_MASK) >> RTCSRW_WAIT_CNT_RD_SHIFT),
     739                                 (uint32_t)((u64State & RTCSRW_CNT_WR_MASK) >> RTCSRW_CNT_WR_SHIFT));
    661740
    662741    return VINF_SUCCESS;
    … …  
    739818        ASMAtomicWriteHandle(&pThis->hNativeWriter, NIL_RTNATIVETHREAD);
    740819
     820        uint64_t u64State = ASMAtomicReadU64(&pThis->u64State);
     821        IPRT_CRITSECTRW_EXCL_LEAVING(pThis, NULL, 0,
     822                                     (uint32_t)((u64State & RTCSRW_WAIT_CNT_RD_MASK) >> RTCSRW_WAIT_CNT_RD_SHIFT),
     823                                     (uint32_t)((u64State & RTCSRW_CNT_WR_MASK) >> RTCSRW_CNT_WR_SHIFT));
     824
    741825        for (;;)
    742826        {
    743             uint64_t u64State    = ASMAtomicReadU64(&pThis->u64State);
    744827            uint64_t u64OldState = u64State;
    745828
    … …  
    782865            if (pThis->u32Magic != RTCRITSECTRW_MAGIC)
    783866                return VERR_SEM_DESTROYED;
     867            u64State = ASMAtomicReadU64(&pThis->u64State);
    784868        }
    785869    }
    … …  
    792876            return rc9;
    793877#endif
    794         ASMAtomicDecU32(&pThis->cWriteRecursions);
     878        uint32_t cNestings = ASMAtomicDecU32(&pThis->cWriteRecursions); NOREF(cNestings);
     879        if (IPRT_CRITSECTRW_EXCL_LEAVING_ENABLED())
     880        {
     881            uint64_t u64State = ASMAtomicReadU64(&pThis->u64State);
     882            IPRT_CRITSECTRW_EXCL_LEAVING(pThis, NULL, cNestings + pThis->cWriterReads,
     883                                         (uint32_t)((u64State & RTCSRW_WAIT_CNT_RD_MASK) >> RTCSRW_WAIT_CNT_RD_SHIFT),
     884                                         (uint32_t)((u64State & RTCSRW_CNT_WR_MASK) >> RTCSRW_CNT_WR_SHIFT));
     885        }
    795886    }
    796887
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