VirtualBox

Changeset 92892 in vbox


Ignore:
Timestamp:
Dec 14, 2021 8:57:53 AM (3 years ago)
Author:
vboxsync
Message:

GVMMR0: Experimental code (disabled) for using HR host timers to wake up EMTs.

Location:
trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/vmm/gvm.h

    r92408 r92892  
    9292        struct GVMMPERVCPU  s;
    9393#endif
    94         uint8_t             padding[64];
     94        uint8_t             padding[256];
    9595    } gvmm;
    9696
    … …  
    133133    /** Padding the structure size to page boundrary. */
    134134#ifdef VBOX_WITH_NEM_R0
    135     uint8_t                 abPadding3[4096 - 64*2 - 64 - 1024 - 64 - 896 - 64];
     135    uint8_t                 abPadding3[4096 - 64*2 - 256 - 1024 - 64 - 896 - 64];
    136136#else
    137     uint8_t                 abPadding3[4096 - 64*2 - 64 - 1024 - 896 - 64];
     137    uint8_t                 abPadding3[4096 - 64*2 - 256 - 1024 - 896 - 64];
    138138#endif
    139139} GVMCPU;

  • trunk/include/VBox/vmm/gvm.mac

    r92408 r92892  
    4444
    4545        alignb 64
    46         .gvmm               resb 64
     46        .gvmm               resb 256
    4747        alignb 64
    4848        .hmr0               resb 1024

  • trunk/include/VBox/vmm/gvmm.h

    r92721 r92892  
    3232
    3333#include <VBox/types.h>
     34#include <VBox/vmm/stam.h>
    3435#include <VBox/sup.h>
     36#include <VBox/param.h>
    3537#include <iprt/cpuset.h> /* RTCPUSET_MAX_CPUS */
    3638
    … …  
    131133
    132134/**
     135 * Per VCpu statistics
     136 */
     137typedef struct GVMMSTATSVMCPU
     138{
     139    uint32_t            cWakeUpTimerHits;
     140    uint32_t            cWakeUpTimerMisses;
     141    uint32_t            cWakeUpTimerCanceled;
     142    uint32_t            cWakeUpTimerSameCpu;
     143    STAMPROFILE         Start;
     144    STAMPROFILE         Stop;
     145} GVMMSTATSVMCPU;
     146/** Ptoiner to the GVMM per VCpu statistics. */
     147typedef GVMMSTATSVMCPU *PGVMMSTATSVMCPU;
     148
     149/**
    133150 * The GVMM statistics.
    134151 */
    … …  
    147164    /** The number of valid entries in aHostCpus. */
    148165    uint32_t            cHostCpus;
     166    /** Per EMT statistics for the specified VM, zero if non specified. */
     167    GVMMSTATSVMCPU      aVCpus[VMM_MAX_CPU_COUNT];
    149168    /** Per host CPU statistics. */
    150169    GVMMSTATSHOSTCPU    aHostCpus[RTCPUSET_MAX_CPUS];

  • trunk/include/VBox/vmm/uvm.h

    r86699 r92892  
    139139        struct STAMUSERPERVM    s;
    140140#endif
    141         uint8_t                 padding[25056];
     141        uint8_t                 padding[30208];
    142142    } stam;
    143143

  • trunk/src/VBox/VMM/VMMR0/GVMMR0.cpp

    r92870 r92892  
    9595/** Define this to enable the periodic preemption timer. */
    9696# define GVMM_SCHED_WITH_PPT
     97#endif
     98
     99#if /*defined(RT_OS_WINDOWS) ||*/ defined(DOXYGEN_RUNNING)
     100/** Define this to enable the per-EMT high resolution wakeup timers. */
     101# define GVMM_SCHED_WITH_HR_WAKE_UP_TIMER
    97102#endif
    98103
    … …  
    253258     */
    254259    uint32_t            nsMinSleepCompany;
     260#ifdef GVMM_SCHED_WITH_HR_WAKE_UP_TIMER
     261    /** @gcfgm{/GVMM/MinSleepWithHrWakeUp,32-bit,0, 100000000, 5000, ns}
     262     * The minimum sleep time for when we've got a high-resolution wake-up timer, in
     263     * nano seconds.
     264     */
     265    uint32_t            nsMinSleepWithHrTimer;
     266#endif
    255267    /** @gcfgm{/GVMM/EarlyWakeUp1, 32-bit, 0, 100000000, 25000, ns}
    256268     * The limit for the first round of early wake-ups, given in nano seconds.
    … …  
    326338#ifdef GVMM_SCHED_WITH_PPT
    327339static DECLCALLBACK(void) gvmmR0SchedPeriodicPreemptionTimerCallback(PRTTIMER pTimer, void *pvUser, uint64_t iTick);
     340#endif
     341#ifdef GVMM_SCHED_WITH_HR_WAKE_UP_TIMER
     342static DECLCALLBACK(void) gvmmR0EmtWakeUpTimerCallback(PRTTIMER pTimer, void *pvUser, uint64_t iTick);
    328343#endif
    329344
    … …  
    400415                pGVMM->nsEarlyWakeUp2    = 0;
    401416            }
     417#ifdef GVMM_SCHED_WITH_HR_WAKE_UP_TIMER
     418            pGVMM->nsMinSleepWithHrTimer = 5000 /* ns (0.005 ms) */;
     419#endif
    402420            pGVMM->fDoEarlyWakeUps = pGVMM->nsEarlyWakeUp1 > 0 && pGVMM->nsEarlyWakeUp2 > 0;
    403421
    … …  
    597615            rc = VERR_OUT_OF_RANGE;
    598616    }
     617#ifdef GVMM_SCHED_WITH_HR_WAKE_UP_TIMER
     618    else if (!strcmp(pszName, "MinSleepWithHrWakeUp"))
     619    {
     620        if (u64Value <= RT_NS_100MS)
     621            pGVMM->nsMinSleepWithHrTimer = u64Value;
     622        else
     623            rc = VERR_OUT_OF_RANGE;
     624    }
     625#endif
    599626    else if (!strcmp(pszName, "EarlyWakeUp1"))
    600627    {
    … …  
    656683    else if (!strcmp(pszName, "MinSleepCompany"))
    657684        *pu64Value = pGVMM->nsMinSleepCompany;
     685#ifdef GVMM_SCHED_WITH_HR_WAKE_UP_TIMER
     686    else if (!strcmp(pszName, "MinSleepWithHrWakeUp"))
     687        *pu64Value = pGVMM->nsMinSleepWithHrTimer;
     688#endif
    658689    else if (!strcmp(pszName, "EarlyWakeUp1"))
    659690        *pu64Value = pGVMM->nsEarlyWakeUp1;
    … …  
    938969                                              ("%p\n", pGVM->paVMPagesR3));
    939970
     971#ifdef GVMM_SCHED_WITH_HR_WAKE_UP_TIMER
     972                                    /*
     973                                     * Create the high resolution wake-up timer for EMT 0, ignore failures.
     974                                     */
     975                                    if (RTTimerCanDoHighResolution())
     976                                    {
     977                                        int rc4 = RTTimerCreateEx(&pGVM->aCpus[0].gvmm.s.hHrWakeUpTimer,
     978                                                                  0 /*one-shot, no interval*/,
     979                                                                  RTTIMER_FLAGS_HIGH_RES, gvmmR0EmtWakeUpTimerCallback,
     980                                                                  &pGVM->aCpus[0]);
     981                                        if (RT_FAILURE(rc4))
     982                                            pGVM->aCpus[0].gvmm.s.hHrWakeUpTimer = NULL;
     983                                    }
     984#endif
     985
    940986                                    /*
    941987                                     * Complete the handle - take the UsedLock sem just to be careful.
    … …  
    11061152        pGVM->aCpus[i].gvmm.s.VMCpuMapObj    = NIL_RTR0MEMOBJ;
    11071153        pGVM->aCpus[i].gvmm.s.idxEmtHash     = UINT16_MAX;
     1154        pGVM->aCpus[i].gvmm.s.hHrWakeUpTimer = NULL;
    11081155        pGVM->aCpus[i].hEMT                  = NIL_RTNATIVETHREAD;
    11091156        pGVM->aCpus[i].pGVM                  = pGVM;
    … …  
    14401487                pGVM->aCpus[i].gvmm.s.VMCpuMapObj = NIL_RTR0MEMOBJ;
    14411488            }
     1489#ifdef GVMM_SCHED_WITH_HR_WAKE_UP_TIMER
     1490            if (pGVM->aCpus[i].gvmm.s.hHrWakeUpTimer != NULL)
     1491            {
     1492                RTTimerDestroy(pGVM->aCpus[i].gvmm.s.hHrWakeUpTimer);
     1493                pGVM->aCpus[i].gvmm.s.hHrWakeUpTimer = NULL;
     1494            }
     1495#endif
    14421496        }
    14431497
    … …  
    14931547        if (idCpu < pGVM->cCpus)
    14941548        {
     1549            PGVMCPU const        pGVCpu      = &pGVM->aCpus[idCpu];
    14951550            RTNATIVETHREAD const hNativeSelf = RTThreadNativeSelf();
    14961551
    … …  
    14981553
    14991554            /* Check that the EMT isn't already assigned to a thread. */
    1500             if (pGVM->aCpus[idCpu].hEMT == NIL_RTNATIVETHREAD)
     1555            if (pGVCpu->hEMT == NIL_RTNATIVETHREAD)
    15011556            {
    1502                 Assert(pGVM->aCpus[idCpu].hNativeThreadR0 == NIL_RTNATIVETHREAD);
     1557                Assert(pGVCpu->hNativeThreadR0 == NIL_RTNATIVETHREAD);
    15031558
    15041559                /* A thread may only be one EMT (this makes sure hNativeSelf isn't NIL). */
    … …  
    15241579                    pGVM->gvmm.s.aEmtHash[idxHash].hNativeEmt = hNativeSelf;
    15251580                    pGVM->gvmm.s.aEmtHash[idxHash].idVCpu     = idCpu;
    1526                     pGVM->aCpus[idCpu].hNativeThreadR0        = hNativeSelf;
    1527                     pGVM->aCpus[idCpu].hEMT                   = hNativeSelf;
    1528                     pGVM->aCpus[idCpu].cEmtHashCollisions     = (uint8_t)cCollisions;
    1529                     pGVM->aCpus[idCpu].gvmm.s.idxEmtHash      = (uint16_t)idxHash;
    1530 
    1531                     rc = VMMR0ThreadCtxHookCreateForEmt(&pGVM->aCpus[idCpu]);
     1581
     1582                    pGVCpu->hNativeThreadR0        = hNativeSelf;
     1583                    pGVCpu->hEMT                   = hNativeSelf;
     1584                    pGVCpu->cEmtHashCollisions     = (uint8_t)cCollisions;
     1585                    pGVCpu->gvmm.s.idxEmtHash      = (uint16_t)idxHash;
     1586
     1587                    rc = VMMR0ThreadCtxHookCreateForEmt(pGVCpu);
    15321588                    if (RT_SUCCESS(rc))
    1533                         CPUMR0RegisterVCpuThread(&pGVM->aCpus[idCpu]);
     1589                    {
     1590                        CPUMR0RegisterVCpuThread(pGVCpu);
     1591
     1592#ifdef GVMM_SCHED_WITH_HR_WAKE_UP_TIMER
     1593                        /*
     1594                         * Create the high resolution wake-up timer, ignore failures.
     1595                         */
     1596                        if (RTTimerCanDoHighResolution())
     1597                        {
     1598                            int rc2 = RTTimerCreateEx(&pGVCpu->gvmm.s.hHrWakeUpTimer, 0 /*one-shot, no interval*/,
     1599                                                      RTTIMER_FLAGS_HIGH_RES, gvmmR0EmtWakeUpTimerCallback, pGVCpu);
     1600                            if (RT_FAILURE(rc2))
     1601                                pGVCpu->gvmm.s.hHrWakeUpTimer = NULL;
     1602                        }
     1603#endif
     1604                    }
    15341605                    else
    15351606                    {
    1536                         pGVM->aCpus[idCpu].hNativeThreadR0        = NIL_RTNATIVETHREAD;
    1537                         pGVM->aCpus[idCpu].hEMT                   = NIL_RTNATIVETHREAD;
     1607                        pGVCpu->hNativeThreadR0                   = NIL_RTNATIVETHREAD;
     1608                        pGVCpu->hEMT                              = NIL_RTNATIVETHREAD;
    15381609                        pGVM->gvmm.s.aEmtHash[idxHash].hNativeEmt = NIL_RTNATIVETHREAD;
    15391610                        pGVM->gvmm.s.aEmtHash[idxHash].idVCpu     = NIL_VMCPUID;
    1540                         pGVM->aCpus[idCpu].gvmm.s.idxEmtHash      = UINT16_MAX;
     1611                        pGVCpu->gvmm.s.idxEmtHash                 = UINT16_MAX;
    15411612                    }
    15421613                }
    … …  
    23532424
    23542425
     2426#ifdef GVMM_SCHED_WITH_HR_WAKE_UP_TIMER
     2427/**
     2428 * Timer callback for the EMT high-resolution wake-up timer.
     2429 *
     2430 * @param   pTimer  The timer handle.
     2431 * @param   pvUser  The global (ring-0) CPU structure for the EMT to wake up.
     2432 * @param   iTick   The current tick.
     2433 */
     2434static DECLCALLBACK(void) gvmmR0EmtWakeUpTimerCallback(PRTTIMER pTimer, void *pvUser, uint64_t iTick)
     2435{
     2436    PGVMCPU pGVCpu = (PGVMCPU)pvUser;
     2437    NOREF(pTimer); NOREF(iTick);
     2438
     2439    pGVCpu->gvmm.s.fHrWakeUptimerArmed = false;
     2440    if (pGVCpu->gvmm.s.u64HaltExpire != 0)
     2441    {
     2442        RTSemEventMultiSignal(pGVCpu->gvmm.s.HaltEventMulti);
     2443        pGVCpu->gvmm.s.Stats.cWakeUpTimerHits += 1;
     2444    }
     2445    else
     2446        pGVCpu->gvmm.s.Stats.cWakeUpTimerMisses += 1;
     2447
     2448    if (RTMpCpuId() == pGVCpu->gvmm.s.idHaltedOnCpu)
     2449        pGVCpu->gvmm.s.Stats.cWakeUpTimerSameCpu += 1;
     2450}
     2451#endif /* GVMM_SCHED_WITH_HR_WAKE_UP_TIMER */
     2452
     2453
    23552454/**
    23562455 * Halt the EMT thread.
    … …  
    23852484    }
    23862485
    2387     pGVCpu->gvmm.s.iCpuEmt = ASMGetApicId();
    2388 
    23892486    /* GIP hack: We might are frequently sleeping for short intervals where the
    23902487       difference between GIP and system time matters on systems with high resolution
    … …  
    24042501    uint64_t cNsInterval = u64ExpireGipTime - u64NowGip;
    24052502    if (    u64NowGip < u64ExpireGipTime
    2406         &&  cNsInterval >= (pGVMM->cEMTs > pGVMM->cEMTsMeansCompany
    2407                             ? pGVMM->nsMinSleepCompany
    2408                             : pGVMM->nsMinSleepAlone))
     2503        &&  (    cNsInterval >= (pGVMM->cEMTs > pGVMM->cEMTsMeansCompany
     2504                                 ? pGVMM->nsMinSleepCompany
     2505                                 : pGVMM->nsMinSleepAlone)
     2506#ifdef GVMM_SCHED_WITH_HR_WAKE_UP_TIMER
     2507             || (pGVCpu->gvmm.s.hHrWakeUpTimer != NULL && cNsInterval >= pGVMM->nsMinSleepWithHrTimer)
     2508#endif
     2509             )
     2510       )
    24092511    {
    24102512        pGVM->gvmm.s.StatsSched.cHaltBlocking++;
    … …  
    24202522        }
    24212523
     2524#ifdef GVMM_SCHED_WITH_HR_WAKE_UP_TIMER
     2525        if (   pGVCpu->gvmm.s.hHrWakeUpTimer != NULL
     2526            && cNsInterval >= RT_MIN(RT_NS_1US, pGVMM->nsMinSleepWithHrTimer))
     2527        {
     2528            STAM_REL_PROFILE_START(&pGVCpu->gvmm.s.Stats.Start, a);
     2529            RTTimerStart(pGVCpu->gvmm.s.hHrWakeUpTimer, cNsInterval);
     2530            pGVCpu->gvmm.s.fHrWakeUptimerArmed = true;
     2531            pGVCpu->gvmm.s.idHaltedOnCpu       = RTMpCpuId();
     2532            STAM_REL_PROFILE_STOP(&pGVCpu->gvmm.s.Stats.Start, a);
     2533        }
     2534#endif
     2535
    24222536        rc = RTSemEventMultiWaitEx(pGVCpu->gvmm.s.HaltEventMulti,
    24232537                                   RTSEMWAIT_FLAGS_ABSOLUTE | RTSEMWAIT_FLAGS_NANOSECS | RTSEMWAIT_FLAGS_INTERRUPTIBLE,
    … …  
    24262540        ASMAtomicWriteU64(&pGVCpu->gvmm.s.u64HaltExpire, 0);
    24272541        ASMAtomicDecU32(&pGVMM->cHaltedEMTs);
     2542
     2543#ifdef GVMM_SCHED_WITH_HR_WAKE_UP_TIMER
     2544        if (!pGVCpu->gvmm.s.fHrWakeUptimerArmed)
     2545        { /* likely */ }
     2546        else
     2547        {
     2548            STAM_REL_PROFILE_START(&pGVCpu->gvmm.s.Stats.Stop, a);
     2549            RTTimerStop(pGVCpu->gvmm.s.hHrWakeUpTimer);
     2550            pGVCpu->gvmm.s.fHrWakeUptimerArmed         = false;
     2551            pGVCpu->gvmm.s.Stats.cWakeUpTimerCanceled += 1;
     2552            STAM_REL_PROFILE_STOP(&pGVCpu->gvmm.s.Stats.Stop, a);
     2553        }
     2554#endif
    24282555
    24292556        /* Reset the semaphore to try prevent a few false wake-ups. */
    … …  
    30713198            return rc;
    30723199        pStats->SchedVM = pGVM->gvmm.s.StatsSched;
     3200
     3201        uint32_t iCpu = RT_MIN(pGVM->cCpus, RT_ELEMENTS(pStats->aVCpus));
     3202        if (iCpu < RT_ELEMENTS(pStats->aVCpus))
     3203            RT_BZERO(&pStats->aVCpus[iCpu], (RT_ELEMENTS(pStats->aVCpus) - iCpu) * sizeof(pStats->aVCpus[0]));
     3204        while (iCpu-- > 0)
     3205            pStats->aVCpus[iCpu] = pGVM->aCpus[iCpu].gvmm.s.Stats;
    30733206    }
    30743207    else
    30753208    {
    30763209        GVMM_GET_VALID_INSTANCE(pGVMM, VERR_GVMM_INSTANCE);
    3077         memset(&pStats->SchedVM, 0, sizeof(pStats->SchedVM));
     3210        RT_ZERO(pStats->SchedVM);
     3211        RT_ZERO(pStats->aVCpus);
    30783212
    30793213        int rc = GVMMR0_USED_SHARED_LOCK(pGVMM);

  • trunk/src/VBox/VMM/VMMR0/GVMMR0Internal.h

    r92200 r92892  
    2323
    2424#include <iprt/mem.h>
     25#include <iprt/timer.h>
     26
    2527
    2628/**
    … …  
    3436    /** The event semaphore the EMT thread is blocking on. */
    3537    RTSEMEVENTMULTI     HaltEventMulti;
     38    /** High resolution wake-up timer, NIL_RTTIMER if not used. */
     39    PRTTIMER            hHrWakeUpTimer;
     40    /** The ID of the CPU we ran on when halting (debug only). */
     41    RTCPUID             idHaltedOnCpu;
     42    /** Set if hHrWakeUpTimer is armed. */
     43    bool volatile       fHrWakeUptimerArmed;
     44    uint8_t             abPadding[1];
     45    /** The EMT hash table index for this VCpu. */
     46    uint16_t            idxEmtHash;
    3647    /** The ring-3 mapping of the VMCPU structure. */
    3748    RTR0MEMOBJ          VMCpuMapObj;
    38     /** The APIC ID of the CPU that EMT was scheduled on the last time we checked.
    39      * @todo Extend to 32-bit and use most suitable APIC ID function when we
    40      *       start using this for something sensible... */
    41     uint8_t             iCpuEmt;
    42     uint8_t             bPadding;
    43     /** The EMT hash table index for this VCpu. */
    44     uint16_t            idxEmtHash;
     49    /** Statistics. */
     50    GVMMSTATSVMCPU      Stats;
    4551} GVMMPERVCPU;
    4652/** Pointer to the GVMM per VCPU data. */

  • trunk/src/VBox/VMM/VMMR3/STAM.cpp

    r92723 r92892  
    219219    { RT_UOFFSETOF(GVMMSTATS, SchedSum.cPollWakeUps),     STAMTYPE_U64_RESET, STAMUNIT_CALLS, "/GVMM/Sum/PollWakeUps", "The number of wake ups done during GVMMR0SchedPoll." },
    220220
    221     { RT_UOFFSETOF(GVMMSTATS, cVMs),                      STAMTYPE_U32,       STAMUNIT_CALLS, "/GVMM/VMs", "The number of VMs accessible to the caller." },
    222     { RT_UOFFSETOF(GVMMSTATS, cEMTs),                     STAMTYPE_U32,       STAMUNIT_CALLS, "/GVMM/EMTs", "The number of emulation threads." },
    223     { RT_UOFFSETOF(GVMMSTATS, cHostCpus),                 STAMTYPE_U32,       STAMUNIT_CALLS, "/GVMM/HostCPUs", "The number of host CPUs." },
     221    { RT_UOFFSETOF(GVMMSTATS, cVMs),                      STAMTYPE_U32,       STAMUNIT_COUNT, "/GVMM/VMs", "The number of VMs accessible to the caller." },
     222    { RT_UOFFSETOF(GVMMSTATS, cEMTs),                     STAMTYPE_U32,       STAMUNIT_COUNT, "/GVMM/EMTs", "The number of emulation threads." },
     223    { RT_UOFFSETOF(GVMMSTATS, cHostCpus),                 STAMTYPE_U32,       STAMUNIT_COUNT, "/GVMM/HostCPUs", "The number of host CPUs." },
    224224};
    225225
    … …  
    29792979                        g_aGVMMStats[i].enmType, STAMVISIBILITY_ALWAYS, g_aGVMMStats[i].pszName,
    29802980                        g_aGVMMStats[i].enmUnit, g_aGVMMStats[i].pszDesc, STAM_REFRESH_GRP_GVMM);
     2981
     2982    for (unsigned i = 0; i < pUVM->cCpus; i++)
     2983    {
     2984        char   szName[120];
     2985        size_t cchBase = RTStrPrintf(szName, sizeof(szName), pUVM->cCpus < 10 ? "/GVMM/VCpus/%u/" : "/GVMM/VCpus/%02u/", i);
     2986
     2987        strcpy(&szName[cchBase], "cWakeUpTimerHits");
     2988        stamR3RegisterU(pUVM, &pUVM->stam.s.GVMMStats.aVCpus[i].cWakeUpTimerHits, NULL, NULL,
     2989                        STAMTYPE_U32, STAMVISIBILITY_ALWAYS, szName, STAMUNIT_OCCURENCES, "", STAM_REFRESH_GRP_GVMM);
     2990
     2991        strcpy(&szName[cchBase], "cWakeUpTimerMisses");
     2992        stamR3RegisterU(pUVM, &pUVM->stam.s.GVMMStats.aVCpus[i].cWakeUpTimerMisses, NULL, NULL,
     2993                        STAMTYPE_U32, STAMVISIBILITY_ALWAYS, szName, STAMUNIT_OCCURENCES, "", STAM_REFRESH_GRP_GVMM);
     2994
     2995        strcpy(&szName[cchBase], "cWakeUpTimerCanceled");
     2996        stamR3RegisterU(pUVM, &pUVM->stam.s.GVMMStats.aVCpus[i].cWakeUpTimerCanceled, NULL, NULL,
     2997                        STAMTYPE_U32, STAMVISIBILITY_ALWAYS, szName, STAMUNIT_OCCURENCES, "", STAM_REFRESH_GRP_GVMM);
     2998
     2999        strcpy(&szName[cchBase], "cWakeUpTimerSameCpu");
     3000        stamR3RegisterU(pUVM, &pUVM->stam.s.GVMMStats.aVCpus[i].cWakeUpTimerSameCpu, NULL, NULL,
     3001                        STAMTYPE_U32, STAMVISIBILITY_ALWAYS, szName, STAMUNIT_OCCURENCES, "", STAM_REFRESH_GRP_GVMM);
     3002
     3003        strcpy(&szName[cchBase], "Start");
     3004        stamR3RegisterU(pUVM, &pUVM->stam.s.GVMMStats.aVCpus[i].Start, NULL, NULL,
     3005                        STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, szName, STAMUNIT_TICKS_PER_CALL, "", STAM_REFRESH_GRP_GVMM);
     3006
     3007        strcpy(&szName[cchBase], "Stop");
     3008        stamR3RegisterU(pUVM, &pUVM->stam.s.GVMMStats.aVCpus[i].Stop, NULL, NULL,
     3009                        STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, szName, STAMUNIT_TICKS_PER_CALL, "", STAM_REFRESH_GRP_GVMM);
     3010    }
    29813011    pUVM->stam.s.cRegisteredHostCpus = 0;
    29823012
Note: See TracChangeset for help on using the changeset viewer.

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