VirtualBox

Changeset 91247 in vbox


Ignore:
Timestamp:
Sep 15, 2021 12:20:52 PM (3 years ago)
Author:
vboxsync
Message:

PGM: Moved the statistics into the VM and VMCPU structures (was on the hyper heap). bugref:10093

Location:
trunk
Files:
14 edited

Legend:

Unmodified
Added
Removed

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

    r90975 r91247  
    290290        struct PGMCPU       s;
    291291#endif
    292         uint8_t             padding[4096];      /* multiple of 4096 */
     292        uint8_t             padding[4096 + 28672]; /* multiple of 4096 */
    293293    } pgm;
    294294
    … …  
    12831283        struct PGM  s;
    12841284#endif
    1285         uint8_t     padding[21120];      /* multiple of 64 */
     1285        uint8_t     padding[21120];     /* multiple of 64 */
    12861286    } pgm;
    12871287

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

    r90975 r91247  
    8989
    9090    alignb 4096
    91     .pgm                    resb 4096
     91    .pgm                    resb 4096+28672
    9292    alignb 4096
    9393    .cpum                   resb 4096

  • trunk/src/VBox/VMM/VMMAll/PGMAll.cpp

    r91016 r91247  
    892892
    893893    Log(("PGMTrap0eHandler: uErr=%RGx pvFault=%RGv eip=%04x:%RGv cr3=%RGp\n", uErr, pvFault, pRegFrame->cs.Sel, (RTGCPTR)pRegFrame->rip, (RTGCPHYS)CPUMGetGuestCR3(pVCpu)));
    894     STAM_PROFILE_START(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0e, a);
     894    STAM_PROFILE_START(&pVCpu->pgm.s.Stats.StatRZTrap0e, a);
    895895    STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = NULL; } );
    896896
    … …  
    905905        {
    906906            if (uErr & X86_TRAP_PF_RW)
    907                 STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eUSNotPresentWrite);
     907                STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.StatRZTrap0eUSNotPresentWrite);
    908908            else
    909                 STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eUSNotPresentRead);
     909                STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.StatRZTrap0eUSNotPresentRead);
    910910        }
    911911        else if (uErr & X86_TRAP_PF_RW)
    912             STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eUSWrite);
     912            STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.StatRZTrap0eUSWrite);
    913913        else if (uErr & X86_TRAP_PF_RSVD)
    914             STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eUSReserved);
     914            STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.StatRZTrap0eUSReserved);
    915915        else if (uErr & X86_TRAP_PF_ID)
    916             STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eUSNXE);
     916            STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.StatRZTrap0eUSNXE);
    917917        else
    918             STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eUSRead);
     918            STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.StatRZTrap0eUSRead);
    919919    }
    920920    else
    … …  
    923923        {
    924924            if (uErr & X86_TRAP_PF_RW)
    925                 STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eSVNotPresentWrite);
     925                STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.StatRZTrap0eSVNotPresentWrite);
    926926            else
    927                 STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eSVNotPresentRead);
     927                STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.StatRZTrap0eSVNotPresentRead);
    928928        }
    929929        else if (uErr & X86_TRAP_PF_RW)
    930             STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eSVWrite);
     930            STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.StatRZTrap0eSVWrite);
    931931        else if (uErr & X86_TRAP_PF_ID)
    932             STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eSNXE);
     932            STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.StatRZTrap0eSNXE);
    933933        else if (uErr & X86_TRAP_PF_RSVD)
    934             STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eSVReserved);
     934            STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.StatRZTrap0eSVReserved);
    935935    }
    936936# endif /* VBOX_WITH_STATISTICS */
    … …  
    971971    }
    972972
    973     STAM_STATS({ if (rc == VINF_EM_RAW_GUEST_TRAP) STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eGuestPF); });
     973    STAM_STATS({ if (rc == VINF_EM_RAW_GUEST_TRAP) STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.StatRZTrap0eGuestPF); });
    974974    STAM_STATS({ if (!pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution))
    975                     pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2Misc; });
    976     STAM_PROFILE_STOP_EX(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0e, pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution), a);
     975                    pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.Stats.StatRZTrap0eTime2Misc; });
     976    STAM_PROFILE_STOP_EX(&pVCpu->pgm.s.Stats.StatRZTrap0e, pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution), a);
    977977    return rc;
    978978}
    … …  
    994994VMMDECL(int) PGMPrefetchPage(PVMCPUCC pVCpu, RTGCPTR GCPtrPage)
    995995{
    996     STAM_PROFILE_START(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Prefetch), a);
     996    STAM_PROFILE_START(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,Prefetch), a);
    997997
    998998    uintptr_t const idxBth = pVCpu->pgm.s.idxBothModeData;
    … …  
    10011001    int rc = g_aPgmBothModeData[idxBth].pfnPrefetchPage(pVCpu, GCPtrPage);
    10021002
    1003     STAM_PROFILE_STOP(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Prefetch), a);
     1003    STAM_PROFILE_STOP(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,Prefetch), a);
    10041004    AssertMsg(rc == VINF_SUCCESS || rc == VINF_PGM_SYNC_CR3 || RT_FAILURE(rc), ("rc=%Rrc\n", rc));
    10051005    return rc;
    … …  
    12241224     * Call paging mode specific worker.
    12251225     */
    1226     STAM_PROFILE_START(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,InvalidatePage), a);
     1226    STAM_PROFILE_START(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,InvalidatePage), a);
    12271227    PGM_LOCK_VOID(pVM);
    12281228
    … …  
    12331233
    12341234    PGM_UNLOCK(pVM);
    1235     STAM_PROFILE_STOP(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,InvalidatePage), a);
     1235    STAM_PROFILE_STOP(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,InvalidatePage), a);
    12361236
    12371237#ifdef IN_RING3
    … …  
    21552155VMMDECL(int)  PGMGstModifyPage(PVMCPUCC pVCpu, RTGCPTR GCPtr, size_t cb, uint64_t fFlags, uint64_t fMask)
    21562156{
    2157     STAM_PROFILE_START(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,GstModifyPage), a);
     2157    STAM_PROFILE_START(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,GstModifyPage), a);
    21582158    VMCPU_ASSERT_EMT(pVCpu);
    21592159
    … …  
    21812181    int rc = g_aPgmGuestModeData[idx].pfnModifyPage(pVCpu, GCPtr, cb, fFlags, fMask);
    21822182
    2183     STAM_PROFILE_STOP(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,GstModifyPage), a);
     2183    STAM_PROFILE_STOP(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,GstModifyPage), a);
    21842184    return rc;
    21852185}
    … …  
    24412441VMMDECL(int) PGMFlushTLB(PVMCPUCC pVCpu, uint64_t cr3, bool fGlobal)
    24422442{
    2443     STAM_PROFILE_START(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,FlushTLB), a);
     2443    STAM_PROFILE_START(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,FlushTLB), a);
    24442444    PVMCC pVM = pVCpu->CTX_SUFF(pVM);
    24452445
    … …  
    25012501
    25022502        if (fGlobal)
    2503             STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,FlushTLBNewCR3Global));
     2503            STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,FlushTLBNewCR3Global));
    25042504        else
    2505             STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,FlushTLBNewCR3));
     2505            STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,FlushTLBNewCR3));
    25062506    }
    25072507    else
    … …  
    25252525        }
    25262526        if (fGlobal)
    2527             STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,FlushTLBSameCR3Global));
     2527            STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,FlushTLBSameCR3Global));
    25282528        else
    2529             STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,FlushTLBSameCR3));
     2529            STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,FlushTLBSameCR3));
    25302530    }
    25312531
    25322532    IEMTlbInvalidateAll(pVCpu, false /*fVmm*/);
    2533     STAM_PROFILE_STOP(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,FlushTLB), a);
     2533    STAM_PROFILE_STOP(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,FlushTLB), a);
    25342534    return rc;
    25352535}
    … …  
    27082708     * Let the 'Bth' function do the work and we'll just keep track of the flags.
    27092709     */
    2710     STAM_PROFILE_START(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,SyncCR3), a);
     2710    STAM_PROFILE_START(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,SyncCR3), a);
    27112711
    27122712    uintptr_t const idxBth = pVCpu->pgm.s.idxBothModeData;
    … …  
    27152715    rc = g_aPgmBothModeData[idxBth].pfnSyncCR3(pVCpu, cr0, cr3, cr4, fGlobal);
    27162716
    2717     STAM_PROFILE_STOP(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,SyncCR3), a);
     2717    STAM_PROFILE_STOP(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,SyncCR3), a);
    27182718    AssertMsg(rc == VINF_SUCCESS || rc == VINF_PGM_SYNC_CR3 || RT_FAILURE(rc), ("rc=%Rrc\n", rc));
    27192719    if (rc == VINF_SUCCESS)
    … …  
    37013701VMMDECL(unsigned) PGMAssertCR3(PVMCC pVM, PVMCPUCC pVCpu, uint64_t cr3, uint64_t cr4)
    37023702{
    3703     STAM_PROFILE_START(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,SyncCR3), a);
     3703    STAM_PROFILE_START(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,SyncCR3), a);
    37043704
    37053705    uintptr_t const idxBth = pVCpu->pgm.s.idxBothModeData;
    … …  
    37113711    PGM_UNLOCK(pVM);
    37123712
    3713     STAM_PROFILE_STOP(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,SyncCR3), a);
     3713    STAM_PROFILE_STOP(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,SyncCR3), a);
    37143714    return cErrors;
    37153715}

  • trunk/src/VBox/VMM/VMMAll/PGMAllBth.h

    r91016 r91247  
    198198        /* Force a CR3 sync to check for conflicts and emulate the instruction. */
    199199        VMCPU_FF_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3);
    200         STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2GuestTrap; });
     200        STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.Stats.StatRZTrap0eTime2GuestTrap; });
    201201        return VINF_EM_RAW_EMULATE_INSTR;
    202202    }
    … …  
    220220
    221221    LogFlow(("Guest trap; cr2=%RGv uErr=%RGv lvl=%d\n", pGstWalk->Core.GCPtr, uErr, pGstWalk->Core.uLevel));
    222     STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2GuestTrap; });
     222    STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.Stats.StatRZTrap0eTime2GuestTrap; });
    223223    return VINF_EM_RAW_GUEST_TRAP;
    224224}
    … …  
    292292                {
    293293                    AssertMsgRC(rcStrict, ("%Rrc\n", VBOXSTRICTRC_VAL(rcStrict)));
    294                     STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eHandlersOutOfSync);
    295                     STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2OutOfSyncHndPhys; });
     294                    STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.StatRZTrap0eHandlersOutOfSync);
     295                    STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.Stats.StatRZTrap0eTime2OutOfSyncHndPhys; });
    296296                    return rcStrict;
    297297                }
    … …  
    319319                {
    320320                    AssertMsgRC(rcStrict, ("%Rrc\n", VBOXSTRICTRC_VAL(rcStrict)));
    321                     STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eHandlersOutOfSync);
    322                     STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2OutOfSyncHndPhys; });
     321                    STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.StatRZTrap0eHandlersOutOfSync);
     322                    STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.Stats.StatRZTrap0eTime2OutOfSyncHndPhys; });
    323323                    return rcStrict;
    324324                }
    … …  
    331331                       pvFault, GCPhysFault, pPage, uErr, pCurType->enmKind));
    332332            if (pCurType->enmKind == PGMPHYSHANDLERKIND_WRITE)
    333                 STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eHandlersPhysWrite);
     333                STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.StatRZTrap0eHandlersPhysWrite);
    334334            else
    335335            {
    336                 STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eHandlersPhysAll);
    337                 if (uErr & X86_TRAP_PF_RSVD) STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eHandlersPhysAllOpt);
     336                STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.StatRZTrap0eHandlersPhysAll);
     337                if (uErr & X86_TRAP_PF_RSVD) STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.StatRZTrap0eHandlersPhysAllOpt);
    338338            }
    339339
    … …  
    363363                rcStrict = VINF_EM_RAW_EMULATE_INSTR;
    364364
    365             STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2HndPhys; });
     365            STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.Stats.StatRZTrap0eTime2HndPhys; });
    366366            return rcStrict;
    367367        }
    … …  
    376376     * write access handlers. Restart the instruction if it wasn't a write access.
    377377     */
    378     STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eHandlersUnhandled);
     378    STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.StatRZTrap0eHandlersUnhandled);
    379379
    380380    if (    !PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(pPage)
    … …  
    391391        {
    392392            AssertMsgRC(rcStrict, ("%Rrc\n", VBOXSTRICTRC_VAL(rcStrict)));
    393             STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eHandlersOutOfSync);
    394             STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2OutOfSyncHndPhys; });
     393            STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.StatRZTrap0eHandlersOutOfSync);
     394            STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.Stats.StatRZTrap0eTime2OutOfSyncHndPhys; });
    395395            return rcStrict;
    396396        }
    … …  
    402402    rcStrict = PGMInterpretInstruction(pVM, pVCpu, pRegFrame, pvFault);
    403403    LogFlow(("PGM: PGMInterpretInstruction -> rcStrict=%d pPage=%R[pgmpage]\n", VBOXSTRICTRC_VAL(rcStrict), pPage));
    404     STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2HndUnhandled; });
     404    STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.Stats.StatRZTrap0eTime2HndUnhandled; });
    405405    return rcStrict;
    406406} /* if any kind of handler */
    … …  
    519519#   ifdef VBOX_WITH_STATISTICS
    520520            if (GstWalk.Pte.u & X86_PTE_D)
    521                 STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PageAlreadyDirty));
     521                STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,PageAlreadyDirty));
    522522            else
    523                 STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,DirtiedPage));
     523                STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,DirtiedPage));
    524524#   endif
    525525            if ((GstWalk.Pte.u & (X86_PTE_A | X86_PTE_D)) != (X86_PTE_A | X86_PTE_D))
    … …  
    622622    if (uErr & X86_TRAP_PF_RW)  /* write fault? */
    623623    {
    624         STAM_PROFILE_START(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,DirtyBitTracking), a);
     624        STAM_PROFILE_START(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,DirtyBitTracking), a);
    625625        rc = PGM_BTH_NAME(CheckDirtyPageFault)(pVCpu, uErr, &pPDDst->a[iPDDst], GstWalk.pPde, pvFault);
    626         STAM_PROFILE_STOP(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,DirtyBitTracking), a);
     626        STAM_PROFILE_STOP(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,DirtyBitTracking), a);
    627627        if (rc == VINF_PGM_HANDLED_DIRTY_BIT_FAULT)
    628628        {
    629629            STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution)
    630630                        = rc == VINF_PGM_HANDLED_DIRTY_BIT_FAULT
    631                           ? &pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2DirtyAndAccessed
    632                           : &pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2GuestTrap; });
     631                          ? &pVCpu->pgm.s.Stats.StatRZTrap0eTime2DirtyAndAccessed
     632                          : &pVCpu->pgm.s.Stats.StatRZTrap0eTime2GuestTrap; });
    633633            Log8(("Trap0eHandler: returns VINF_SUCCESS\n"));
    634634            return VINF_SUCCESS;
    … …  
    663663        &&  !SHW_PDE_IS_P(pPDDst->a[iPDDst]))
    664664    {
    665         STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2SyncPT; });
     665        STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.Stats.StatRZTrap0eTime2SyncPT; });
    666666#  if PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE)
    667667        LogFlow(("=>SyncPT %04x = %08RX64\n", (pvFault >> GST_PD_SHIFT) & GST_PD_MASK, (uint64_t)GstWalk.Pde.u));
    … …  
    704704                        if (GstWalk.pPde[iPT].n.u1Present)
    705705                        {
    706                             STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eConflicts);
     706                            STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.StatRZTrap0eConflicts);
    707707                            Log(("Trap0e: Detected Conflict %RGv-%RGv\n", pMapping->GCPtr, pMapping->GCPtrLast));
    708708                            VMCPU_FF_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3); /** @todo no need to do global sync,right? */
    709                             STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2Mapping; });
     709                            STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.Stats.StatRZTrap0eTime2Mapping; });
    710710                            return VINF_PGM_SYNC_CR3;
    711711                        }
    … …  
    716716                 */
    717717                TRPMSetErrorCode(pVCpu, uErr & ~X86_TRAP_PF_P);
    718                 STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eGuestPFMapping);
     718                STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.StatRZTrap0eGuestPFMapping);
    719719                LogFlow(("PGM: Mapping access -> route trap to recompiler!\n"));
    720                 STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2Mapping; });
     720                STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.Stats.StatRZTrap0eTime2Mapping; });
    721721                return VINF_EM_RAW_GUEST_TRAP;
    722722            }
    … …  
    748748         */
    749749        LogFlow(("PGM #PF: pgmPhysGetPageEx(%RGp) failed with %Rrc\n", GCPhys, rc));
    750         STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eHandlersInvalid);
    751         STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2InvalidPhys; });
     750        STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.StatRZTrap0eHandlersInvalid);
     751        STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.Stats.StatRZTrap0eTime2InvalidPhys; });
    752752        return VINF_EM_RAW_EMULATE_INSTR;
    753753    }
    … …  
    776776         */
    777777        if (uErr & X86_TRAP_PF_US)
    778             STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PageOutOfSyncUser));
     778            STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,PageOutOfSyncUser));
    779779        else /* supervisor */
    780             STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PageOutOfSyncSupervisor));
     780            STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,PageOutOfSyncSupervisor));
    781781
    782782        if (PGM_PAGE_IS_BALLOONED(pPage))
    … …  
    787787            rc = VBOXSTRICTRC_TODO(PGMInterpretInstruction(pVM, pVCpu, pRegFrame, pvFault));
    788788            LogFlow(("PGM: PGMInterpretInstruction balloon -> rc=%d pPage=%R[pgmpage]\n", rc, pPage));
    789             STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PageOutOfSyncBallloon));
    790             STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2Ballooned; });
     789            STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,PageOutOfSyncBallloon));
     790            STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.Stats.StatRZTrap0eTime2Ballooned; });
    791791            return rc;
    792792        }
    … …  
    800800        {
    801801            /* The page was successfully synced, return to the guest. */
    802             STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2OutOfSync; });
     802            STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.Stats.StatRZTrap0eTime2OutOfSync; });
    803803            return VINF_SUCCESS;
    804804        }
    … …  
    827827                Assert(!PGM_PAGE_IS_ZERO(pPage));
    828828                AssertFatalMsg(!PGM_PAGE_IS_BALLOONED(pPage), ("Unexpected ballooned page at %RGp\n", GCPhys));
    829                 STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2MakeWritable; });
     829                STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.Stats.StatRZTrap0eTime2MakeWritable; });
    830830
    831831                rc = pgmPhysPageMakeWritable(pVM, pPage, GCPhys);
    … …  
    873873                        PGM_INVL_PG(pVCpu, pvFault);
    874874                        pVCpu->pgm.s.cNetwareWp0Hacks++;
    875                         STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2Wp0RoUsHack; });
     875                        STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.Stats.StatRZTrap0eTime2Wp0RoUsHack; });
    876876                        return rc;
    877877                    }
    … …  
    885885                Log(("PGM #PF: WP0 emulation (pvFault=%RGp uErr=%#x cpl=%d fBig=%d fEffUs=%d)\n", pvFault, uErr, CPUMGetGuestCPL(pVCpu), GstWalk.Core.fBigPage, GstWalk.Core.fEffectiveUS));
    886886                if (RT_SUCCESS(rc))
    887                     STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eWPEmulInRZ);
     887                    STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.StatRZTrap0eWPEmulInRZ);
    888888                else
    889                     STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eWPEmulToR3);
    890                 STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2WPEmulation; });
     889                    STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.StatRZTrap0eWPEmulToR3);
     890                STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.Stats.StatRZTrap0eTime2WPEmulation; });
    891891                return rc;
    892892            }
    … …  
    894894            /// @todo count the above case; else
    895895            if (uErr & X86_TRAP_PF_US)
    896                 STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PageOutOfSyncUserWrite));
     896                STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,PageOutOfSyncUserWrite));
    897897            else /* supervisor */
    898                 STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PageOutOfSyncSupervisorWrite));
     898                STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,PageOutOfSyncSupervisorWrite));
    899899
    900900            /*
    … …  
    936936#    endif
    937937#   endif /* VBOX_STRICT */
    938                 STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2OutOfSyncHndObs; });
     938                STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.Stats.StatRZTrap0eTime2OutOfSyncHndObs; });
    939939                return VINF_SUCCESS;
    940940            }
    … …  
    960960                PGM_INVL_PG(pVCpu, pvFault);
    961961                pVCpu->pgm.s.cNetwareWp0Hacks--;
    962                 STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2Wp0RoUsUnhack; });
     962                STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.Stats.StatRZTrap0eTime2Wp0RoUsUnhack; });
    963963                return VINF_SUCCESS;
    964964            }
    … …  
    10851085    if (!pShwPde)
    10861086    {
    1087         STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,InvalidatePageSkipped));
     1087        STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,InvalidatePageSkipped));
    10881088        return VINF_SUCCESS;
    10891089    }
    … …  
    11061106        Assert(!pPdptDst || !(pPdptDst->a[iPdpt].u & PGM_PLXFLAGS_MAPPING));
    11071107#  endif
    1108         STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,InvalidatePageSkipped));
     1108        STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,InvalidatePageSkipped));
    11091109        PGM_INVL_PG(pVCpu, GCPtrPage);
    11101110        return VINF_SUCCESS;
    … …  
    11311131    {
    11321132        AssertMsg(rc == VERR_PAGE_DIRECTORY_PTR_NOT_PRESENT || rc == VERR_PAGE_MAP_LEVEL4_NOT_PRESENT, ("Unexpected rc=%Rrc\n", rc));
    1133         STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,InvalidatePageSkipped));
     1133        STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,InvalidatePageSkipped));
    11341134        PGM_INVL_PG(pVCpu, GCPtrPage);
    11351135        return VINF_SUCCESS;
    … …  
    11481148    if (!(PdeDst.u & X86_PDE_P))
    11491149    {
    1150         STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,InvalidatePageSkipped));
     1150        STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,InvalidatePageSkipped));
    11511151        PGM_INVL_PG(pVCpu, GCPtrPage);
    11521152        return VINF_SUCCESS;
    … …  
    11801180    const bool      fIsBigPage  = (PdeSrc.u & X86_PDE_PS) && GST_IS_PSE_ACTIVE(pVCpu);
    11811181    if (fWasBigPage != fIsBigPage)
    1182         STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,InvalidatePageSkipped));
     1182        STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,InvalidatePageSkipped));
    11831183
    11841184# ifdef IN_RING3
    … …  
    11991199#  endif
    12001200    {
    1201         STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,InvalidatePageSkipped));
     1201        STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,InvalidatePageSkipped));
    12021202        return VINF_SUCCESS;
    12031203    }
    … …  
    12571257                            SHW_PTE_IS_TRACK_DIRTY(pPTDst->a[iPTDst]) ? " Track-Dirty" : ""));
    12581258                }
    1259                 STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,InvalidatePage4KBPages));
     1259                STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,InvalidatePage4KBPages));
    12601260                PGM_INVL_PG(pVCpu, GCPtrPage);
    12611261            }
    … …  
    12691269                pgmPoolFree(pVM, PdeDst.u & SHW_PDE_PG_MASK, pShwPde->idx, iPDDst);
    12701270                SHW_PDE_ATOMIC_SET(*pPdeDst, 0);
    1271                 STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,InvalidatePagePDOutOfSync));
     1271                STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,InvalidatePagePDOutOfSync));
    12721272                PGM_INVL_VCPU_TLBS(pVCpu);
    12731273            }
    … …  
    12971297                {
    12981298                    LogFlow(("Skipping flush for big page containing %RGv (PD=%X .u=%RX64)-> nothing has changed!\n", GCPtrPage, iPDSrc, PdeSrc.u));
    1299                     STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,InvalidatePage4MBPagesSkip));
     1299                    STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,InvalidatePage4MBPagesSkip));
    13001300                    return VINF_SUCCESS;
    13011301                }
    … …  
    13121312            pgmPoolFree(pVM, PdeDst.u & SHW_PDE_PG_MASK, pShwPde->idx, iPDDst);
    13131313            SHW_PDE_ATOMIC_SET(*pPdeDst, 0);
    1314             STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,InvalidatePage4MBPages));
     1314            STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,InvalidatePage4MBPages));
    13151315            PGM_INVL_BIG_PG(pVCpu, GCPtrPage);
    13161316        }
    … …  
    13271327            pgmPoolFree(pVM, PdeDst.u & SHW_PDE_PG_MASK, pShwPde->idx, iPDDst);
    13281328            SHW_PDE_ATOMIC_SET(*pPdeDst, 0);
    1329             STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,InvalidatePagePDNPs));
     1329            STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,InvalidatePagePDNPs));
    13301330            PGM_INVL_PG(pVCpu, GCPtrPage);
    13311331        }
    … …  
    13341334        {
    13351335            Assert(pgmMapAreMappingsEnabled(pVM));
    1336             STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,InvalidatePagePDMappings));
     1336            STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,InvalidatePagePDMappings));
    13371337        }
    13381338# endif
    … …  
    13861386# endif
    13871387
    1388     STAM_PROFILE_START(&pVM->pgm.s.CTX_SUFF(pStats)->StatTrackDeref, a);
     1388    STAM_PROFILE_START(&pVM->pgm.s.Stats.StatTrackDeref, a);
    13891389    LogFlow(("SyncPageWorkerTrackDeref: Damn HCPhys=%RHp pShwPage->idx=%#x!!!\n", HCPhys, pShwPage->idx));
    13901390
    … …  
    14151415
    14161416                pgmTrackDerefGCPhys(pPool, pShwPage, &pRam->aPages[iPage], iPte);
    1417                 STAM_PROFILE_STOP(&pVM->pgm.s.CTX_SUFF(pStats)->StatTrackDeref, a);
     1417                STAM_PROFILE_STOP(&pVM->pgm.s.Stats.StatTrackDeref, a);
    14181418                return;
    14191419            }
    … …  
    14441444    if (!u16)
    14451445    {
    1446         STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->StatTrackVirgin);
     1446        STAM_COUNTER_INC(&pVM->pgm.s.Stats.StatTrackVirgin);
    14471447        u16 = PGMPOOL_TD_MAKE(1, pShwPage->idx);
    14481448        /* Save the page table index. */
    … …  
    16471647                {
    16481648                    LogFlow(("SyncPageWorker: page and or page directory not accessed -> mark not present\n"));
    1649                     STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,AccessedPage));
     1649                    STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,AccessedPage));
    16501650                    SHW_PTE_SET(PteDst, 0);
    16511651                }
    … …  
    16571657                {
    16581658                    AssertCompile(X86_PTE_RW == X86_PDE_RW);
    1659                     STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,DirtyPage));
     1659                    STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,DirtyPage));
    16601660                    SHW_PTE_SET(PteDst,
    16611661                                  fGstShwPteFlags
    … …  
    16671667# endif
    16681668                {
    1669                     STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,DirtyPageSkipped));
     1669                    STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,DirtyPageSkipped));
    16701670# if PGM_SHW_TYPE == PGM_TYPE_EPT
    16711671                    PteDst.u = PGM_PAGE_GET_HCPHYS(pPage)
    … …  
    20402040                    if ((PdeSrc.u & (X86_PDE4M_D | X86_PDE_RW)) == X86_PDE_RW)
    20412041                    {
    2042                         STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,DirtyPageBig));
     2042                        STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,DirtyPageBig));
    20432043                        PdeDst.u |= PGM_PDFLAGS_TRACK_DIRTY;
    20442044                        PdeDst.u &= ~(SHWUINT)X86_PDE_RW;
    … …  
    20652065        }
    20662066
    2067         STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,SyncPagePDNAs));
     2067        STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,SyncPagePDNAs));
    20682068    }
    20692069    else if (fPdeValid)
    20702070    {
    2071         STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,SyncPagePDOutOfSync));
     2071        STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,SyncPagePDOutOfSync));
    20722072        Log2(("SyncPage: Out-Of-Sync PDE at %RGp PdeSrc=%RX64 PdeDst=%RX64 (GCPhys %RGp vs %RGp)\n",
    20732073              GCPtrPage, (uint64_t)PdeSrc.u, (uint64_t)PdeDst.u, pShwPage->GCPhys, GCPhys));
    … …  
    22322232DECLINLINE(int) PGM_BTH_NAME(CheckPageFaultReturnNP)(PVMCPUCC pVCpu, uint32_t uErr, RTGCPTR GCPtrPage, unsigned uPageFaultLevel)
    22332233{
    2234     STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,DirtyTrackRealPF));
     2234    STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,DirtyTrackRealPF));
    22352235    AssertMsg(!(uErr & X86_TRAP_PF_P), ("%#x\n", uErr));
    22362236    AssertMsg(!(uErr & X86_TRAP_PF_RSVD), ("%#x\n", uErr));
    … …  
    22572257DECLINLINE(int) PGM_BTH_NAME(CheckPageFaultReturnRSVD)(PVMCPUCC pVCpu, uint32_t uErr, RTGCPTR GCPtrPage, unsigned uPageFaultLevel)
    22582258{
    2259     STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,DirtyTrackRealPF));
     2259    STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,DirtyTrackRealPF));
    22602260    if ((uErr & (X86_TRAP_PF_RSVD | X86_TRAP_PF_P)) != (X86_TRAP_PF_RSVD | X86_TRAP_PF_P))
    22612261        TRPMSetErrorCode(pVCpu, uErr | X86_TRAP_PF_RSVD | X86_TRAP_PF_P);
    … …  
    22792279DECLINLINE(int) PGM_BTH_NAME(CheckPageFaultReturnProt)(PVMCPUCC pVCpu, uint32_t uErr, RTGCPTR GCPtrPage, unsigned uPageFaultLevel)
    22802280{
    2281     STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,DirtyTrackRealPF));
     2281    STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,DirtyTrackRealPF));
    22822282    AssertMsg(uErr & (X86_TRAP_PF_RW | X86_TRAP_PF_US | X86_TRAP_PF_ID), ("%#x\n", uErr));
    22832283    if ((uErr & (X86_TRAP_PF_P | X86_TRAP_PF_RSVD)) != X86_TRAP_PF_P)
    … …  
    23162316        if ((pPdeDst->u & (X86_PDE_P | PGM_PDFLAGS_TRACK_DIRTY)) == (X86_PDE_P | PGM_PDFLAGS_TRACK_DIRTY))
    23172317        {
    2318             STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,DirtyPageTrap));
     2318            STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,DirtyPageTrap));
    23192319            Assert(pPdeSrc->u & X86_PDE_RW);
    23202320
    … …  
    23422342                {
    23432343                    /* Stale TLB entry. */
    2344                     STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,DirtyPageStale));
     2344                    STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,DirtyPageStale));
    23452345                    PGM_INVL_PG(pVCpu, GCPtrPage);
    23462346                    return VINF_PGM_HANDLED_DIRTY_BIT_FAULT;    /* restarts the instruction. */
    … …  
    23802380
    23812381                    LogFlow(("DIRTY page trap addr=%RGv\n", GCPtrPage));
    2382                     STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,DirtyPageTrap));
     2382                    STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,DirtyPageTrap));
    23832383
    23842384                    Assert(PteSrc.u & X86_PTE_RW);
    … …  
    24312431                {
    24322432                    /* Stale TLB entry. */
    2433                     STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,DirtyPageStale));
     2433                    STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,DirtyPageStale));
    24342434                    PGM_INVL_PG(pVCpu, GCPtrPage);
    24352435                    return VINF_PGM_HANDLED_DIRTY_BIT_FAULT;    /* restarts the instruction. */
    … …  
    24872487    int             rc       = VINF_SUCCESS;
    24882488
    2489     STAM_PROFILE_START(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,SyncPT), a);
     2489    STAM_PROFILE_START(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,SyncPT), a);
    24902490
    24912491    /*
    … …  
    25492549#  ifndef IN_RING3
    25502550        Log(("SyncPT: Conflict at %RGv\n", GCPtrPage));
    2551         STAM_PROFILE_STOP(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,SyncPT), a);
     2551        STAM_PROFILE_STOP(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,SyncPT), a);
    25522552        return VERR_ADDRESS_CONFLICT;
    25532553
    … …  
    25642564        if (RT_FAILURE(rc))
    25652565        {
    2566             STAM_PROFILE_STOP(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,SyncPT), a);
     2566            STAM_PROFILE_STOP(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,SyncPT), a);
    25672567            return rc;
    25682568        }
    … …  
    26462646                if ((PdeSrc.u & (X86_PDE_RW | X86_PDE4M_D)) == X86_PDE_RW)
    26472647                {
    2648                     STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,DirtyPageBig));
     2648                    STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,DirtyPageBig));
    26492649                    PdeDst.u |= PGM_PDFLAGS_TRACK_DIRTY;
    26502650                    PdeDst.u &= ~(SHWUINT)X86_PDE_RW;
    … …  
    27092709                 *
    27102710                 */
    2711                 STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,SyncPT4K));
     2711                STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,SyncPT4K));
    27122712# ifdef PGM_SYNC_N_PAGES
    27132713                unsigned        iPTBase   = (GCPtrPage >> SHW_PT_SHIFT) & SHW_PT_MASK;
    … …  
    27582758             * We will only sync one shadow page table at a time.
    27592759             */
    2760             STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,SyncPT4M));
     2760            STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,SyncPT4M));
    27612761
    27622762            /**
    … …  
    27832783            if ((PdeSrc.u & (X86_PDE_RW | X86_PDE4M_D)) == X86_PDE_RW)
    27842784            {
    2785                 STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,DirtyPageBig));
     2785                STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,DirtyPageBig));
    27862786                PdeDst.u |= PGM_PDFLAGS_TRACK_DIRTY;
    27872787                PdeDst.u &= ~(SHWUINT)X86_PDE_RW;
    … …  
    29092909        AssertRelease(!SHW_PDE_IS_P(PdeDst));
    29102910
    2911     STAM_PROFILE_STOP(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,SyncPT), a);
     2911    STAM_PROFILE_STOP(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,SyncPT), a);
    29122912    if (RT_FAILURE(rc))
    2913         STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,SyncPTFailed));
     2913        STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,SyncPTFailed));
    29142914    return rc;
    29152915
    … …  
    29202920    NOREF(iPDSrc); NOREF(pPDSrc);
    29212921
    2922     STAM_PROFILE_START(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,SyncPT), a);
     2922    STAM_PROFILE_START(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,SyncPT), a);
    29232923
    29242924    /*
    … …  
    29712971    if (rc != VINF_SUCCESS)
    29722972    {
    2973         STAM_PROFILE_STOP(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,SyncPT), a);
     2973        STAM_PROFILE_STOP(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,SyncPT), a);
    29742974        AssertRC(rc);
    29752975        return rc;
    … …  
    30553055                PGM_BTH_NAME(SyncPageWorkerTrackAddref)(pVCpu, pShwPde, PGM_PAGE_GET_TRACKING(pPage), pPage, iPDDst);
    30563056
    3057                 STAM_PROFILE_STOP(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,SyncPT), a);
     3057                STAM_PROFILE_STOP(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,SyncPT), a);
    30583058                return VINF_SUCCESS;
    30593059            }
    … …  
    30793079    else
    30803080    {
    3081        STAM_PROFILE_STOP(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,SyncPT), a);
     3081       STAM_PROFILE_STOP(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,SyncPT), a);
    30823082       AssertMsgFailedReturn(("rc=%Rrc\n", rc), RT_FAILURE_NP(rc) ? rc : VERR_IPE_UNEXPECTED_INFO_STATUS);
    30833083    }
    … …  
    31193119    SHW_PDE_ATOMIC_SET2(*pPdeDst, PdeDst);
    31203120
    3121     STAM_PROFILE_STOP(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,SyncPT), a);
     3121    STAM_PROFILE_STOP(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,SyncPT), a);
    31223122    if (RT_FAILURE(rc))
    3123         STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,SyncPTFailed));
     3123        STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,SyncPTFailed));
    31243124    return rc;
    31253125
    … …  
    34163416        Assert(rc != VINF_EM_RAW_GUEST_TRAP);
    34173417        if (uErr & X86_TRAP_PF_US)
    3418             STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PageOutOfSyncUser));
     3418            STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,PageOutOfSyncUser));
    34193419        else /* supervisor */
    3420             STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PageOutOfSyncSupervisor));
     3420            STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.CTX_MID_Z(Stat,PageOutOfSyncSupervisor));
    34213421
    34223422        rc = PGM_BTH_NAME(SyncPage)(pVCpu, PdeSrc, GCPtrPage, 1, 0);

  • trunk/src/VBox/VMM/VMMAll/PGMAllHandler.cpp

    r90439 r91247  
    11381138            case PGMPHYSHANDLERKIND_MMIO: /* NOTE: Only use when clearing MMIO ranges with aliased MMIO2 pages! */
    11391139            {
    1140                 STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PhysHandlerReset)); /** @todo move out of switch */
     1140                STAM_COUNTER_INC(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,PhysHandlerReset)); /** @todo move out of switch */
    11411141                PPGMRAMRANGE pRam = pgmPhysGetRange(pVM, GCPhys);
    11421142                Assert(pRam);

  • trunk/src/VBox/VMM/VMMAll/PGMAllMap.cpp

    r90439 r91247  
    769769                if (pPD->a[iPDE + iPT].n.u1Present /** @todo PGMGstGetPDE. */)
    770770                {
    771                     STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->StatR3DetectedConflicts);
     771                    STAM_COUNTER_INC(&pVM->pgm.s.Stats.StatR3DetectedConflicts);
    772772
    773773# ifdef IN_RING3
    … …  
    800800                if (Pde.n.u1Present)
    801801                {
    802                     STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->StatR3DetectedConflicts);
     802                    STAM_COUNTER_INC(&pVM->pgm.s.Stats.StatR3DetectedConflicts);
    803803# ifdef IN_RING3
    804804                    Log(("PGMHasMappingConflicts: Conflict was detected at %RGv for mapping %s (PAE)\n"
    … …  
    861861                if (pPD->a[iPDE + iPT].n.u1Present /** @todo PGMGstGetPDE. */)
    862862                {
    863                     STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->StatR3DetectedConflicts);
     863                    STAM_COUNTER_INC(&pVM->pgm.s.Stats.StatR3DetectedConflicts);
    864864
    865865# ifdef IN_RING3
    … …  
    900900                if (Pde.n.u1Present)
    901901                {
    902                     STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->StatR3DetectedConflicts);
     902                    STAM_COUNTER_INC(&pVM->pgm.s.Stats.StatR3DetectedConflicts);
    903903# ifdef IN_RING3
    904904                    Log(("PGMHasMappingConflicts: Conflict was detected at %RGv for mapping %s (PAE)\n"

  • trunk/src/VBox/VMM/VMMAll/PGMAllPhys.cpp

    r91246 r91247  
    181181                    case OP_MOV:
    182182                        pRegFrame->rip += cbOp;
    183                         STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZGuestROMWriteHandled);
     183                        STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.StatRZGuestROMWriteHandled);
    184184                        return VINF_SUCCESS;
    185185                }
    … …  
    205205    }
    206206
    207     STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZGuestROMWriteUnhandled);
     207    STAM_COUNTER_INC(&pVCpu->pgm.s.Stats.StatRZGuestROMWriteUnhandled);
    208208    return VINF_EM_RAW_EMULATE_INSTR;
    209209}
    … …  
    344344PPGMRAMRANGE pgmPhysGetRangeSlow(PVM pVM, RTGCPHYS GCPhys)
    345345{
    346     STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,RamRangeTlbMisses));
     346    STAM_COUNTER_INC(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,RamRangeTlbMisses));
    347347
    348348    PPGMRAMRANGE pRam = pVM->pgm.s.CTX_SUFF(pRamRangeTree);
    … …  
    371371PPGMRAMRANGE pgmPhysGetRangeAtOrAboveSlow(PVM pVM, RTGCPHYS GCPhys)
    372372{
    373     STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,RamRangeTlbMisses));
     373    STAM_COUNTER_INC(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,RamRangeTlbMisses));
    374374
    375375    PPGMRAMRANGE pLastLeft = NULL;
    … …  
    402402PPGMPAGE pgmPhysGetPageSlow(PVM pVM, RTGCPHYS GCPhys)
    403403{
    404     STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,RamRangeTlbMisses));
     404    STAM_COUNTER_INC(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,RamRangeTlbMisses));
    405405
    406406    PPGMRAMRANGE pRam = pVM->pgm.s.CTX_SUFF(pRamRangeTree);
    … …  
    430430int pgmPhysGetPageExSlow(PVM pVM, RTGCPHYS GCPhys, PPPGMPAGE ppPage)
    431431{
    432     STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,RamRangeTlbMisses));
     432    STAM_COUNTER_INC(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,RamRangeTlbMisses));
    433433
    434434    PPGMRAMRANGE pRam = pVM->pgm.s.CTX_SUFF(pRamRangeTree);
    … …  
    461461int pgmPhysGetPageAndRangeExSlow(PVM pVM, RTGCPHYS GCPhys, PPPGMPAGE ppPage, PPGMRAMRANGE *ppRam)
    462462{
    463     STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,RamRangeTlbMisses));
     463    STAM_COUNTER_INC(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,RamRangeTlbMisses));
    464464
    465465    PPGMRAMRANGE pRam = pVM->pgm.s.CTX_SUFF(pRamRangeTree);
    … …  
    566566{
    567567    PGM_LOCK_VOID(pVM);
    568     STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->StatPageMapTlbFlushes);
     568    STAM_COUNTER_INC(&pVM->pgm.s.Stats.StatPageMapTlbFlushes);
    569569
    570570    /* Clear the R3 & R0 TLBs completely. */
    … …  
    598598    PGM_LOCK_ASSERT_OWNER(pVM);
    599599
    600     STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->StatPageMapTlbFlushEntry);
     600    STAM_COUNTER_INC(&pVM->pgm.s.Stats.StatPageMapTlbFlushEntry);
    601601
    602602    unsigned const idx = PGM_PAGER3MAPTLB_IDX(GCPhys);
    … …  
    807807        Log(("PGM: Replaced shared page %#x at %RGp with %#x / %RHp\n", PGM_PAGE_GET_PAGEID(pPage),
    808808             GCPhys, pVM->pgm.s.aHandyPages[iHandyPage].idPage, HCPhys));
    809         STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PageReplaceShared));
     809        STAM_COUNTER_INC(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,PageReplaceShared));
    810810        pVM->pgm.s.cSharedPages--;
    811811
    … …  
    817817    {
    818818        Log2(("PGM: Replaced zero page %RGp with %#x / %RHp\n", GCPhys, pVM->pgm.s.aHandyPages[iHandyPage].idPage, HCPhys));
    819         STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->StatRZPageReplaceZero);
     819        STAM_COUNTER_INC(&pVM->pgm.s.Stats.StatRZPageReplaceZero);
    820820        pVM->pgm.s.cZeroPages--;
    821821    }
    … …  
    998998    }
    999999
    1000     STAM_PROFILE_START(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,IsValidLargePage), a);
     1000    STAM_PROFILE_START(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,IsValidLargePage), a);
    10011001    /* Check all remaining pages in the 2 MB range. */
    10021002    unsigned i;
    … …  
    10191019        GCPhys += PAGE_SIZE;
    10201020    }
    1021     STAM_PROFILE_STOP(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,IsValidLargePage), a);
     1021    STAM_PROFILE_STOP(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,IsValidLargePage), a);
    10221022
    10231023    if (i == _2M/PAGE_SIZE)
    … …  
    11601160    if (pTlbe->idChunk == idChunk)
    11611161    {
    1162         STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,ChunkR3MapTlbHits));
     1162        STAM_COUNTER_INC(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,ChunkR3MapTlbHits));
    11631163        pMap = pTlbe->pChunk;
    11641164    }
    11651165    else
    11661166    {
    1167         STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,ChunkR3MapTlbMisses));
     1167        STAM_COUNTER_INC(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,ChunkR3MapTlbMisses));
    11681168
    11691169        /*
    … …  
    12851285    if (pTlbe->idChunk == idChunk)
    12861286    {
    1287         STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,ChunkR3MapTlbHits));
     1287        STAM_COUNTER_INC(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,ChunkR3MapTlbHits));
    12881288        pMap = pTlbe->pChunk;
    12891289        AssertPtr(pMap->pv);
    … …  
    12911291    else
    12921292    {
    1293         STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,ChunkR3MapTlbMisses));
     1293        STAM_COUNTER_INC(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,ChunkR3MapTlbMisses));
    12941294
    12951295        /*
    … …  
    14351435    if (!pPage)
    14361436    {
    1437         STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PageMapTlbMisses));
     1437        STAM_COUNTER_INC(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,PageMapTlbMisses));
    14381438        return VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS;
    14391439    }
    … …  
    14581458{
    14591459    PGM_LOCK_ASSERT_OWNER(pVM);
    1460     STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PageMapTlbMisses));
     1460    STAM_COUNTER_INC(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,PageMapTlbMisses));
    14611461
    14621462    /*
    … …  
    23752375    LogFlow(("PGMPhysRead: %RGp %d\n", GCPhys, cbRead));
    23762376
    2377     STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PhysRead));
    2378     STAM_COUNTER_ADD(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PhysReadBytes), cbRead);
     2377    STAM_COUNTER_INC(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,PhysRead));
     2378    STAM_COUNTER_ADD(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,PhysReadBytes), cbRead);
    23792379
    23802380    PGM_LOCK_VOID(pVM);
    … …  
    27612761    LogFlow(("PGMPhysWrite: %RGp %d\n", GCPhys, cbWrite));
    27622762
    2763     STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PhysWrite));
    2764     STAM_COUNTER_ADD(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PhysWriteBytes), cbWrite);
     2763    STAM_COUNTER_INC(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,PhysWrite));
     2764    STAM_COUNTER_ADD(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,PhysWriteBytes), cbWrite);
    27652765
    27662766    PGM_LOCK_VOID(pVM);
    … …  
    30293029        return VINF_SUCCESS;
    30303030
    3031     STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PhysSimpleRead));
    3032     STAM_COUNTER_ADD(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PhysSimpleReadBytes), cb);
     3031    STAM_COUNTER_INC(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,PhysSimpleRead));
     3032    STAM_COUNTER_ADD(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,PhysSimpleReadBytes), cb);
    30333033
    30343034    /* Take the PGM lock here, because many called functions take the lock for a very short period. That's counter-productive
    … …  
    31203120        return VINF_SUCCESS;
    31213121
    3122     STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PhysSimpleWrite));
    3123     STAM_COUNTER_ADD(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PhysSimpleWriteBytes), cb);
     3122    STAM_COUNTER_INC(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,PhysSimpleWrite));
     3123    STAM_COUNTER_ADD(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,PhysSimpleWriteBytes), cb);
    31243124
    31253125    /* map the 1st page */

  • trunk/src/VBox/VMM/VMMAll/PGMAllPool.cpp

    r91243 r91247  
    39643964        paPhysExts[iPhysExt].aidx[1] = iShwPT;
    39653965        paPhysExts[iPhysExt].apte[1] = iPte;
    3966         STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->StatTrackAliasedMany);
     3966        STAM_COUNTER_INC(&pVM->pgm.s.Stats.StatTrackAliasedMany);
    39673967        LogFlow(("pgmPoolTrackPhysExtInsert: %d:{,%d pte %d,}\n", iPhysExt, iShwPT, iPte));
    39683968        return PGMPOOL_TD_MAKE(PGMPOOL_TD_CREFS_PHYSEXT, iPhysExt);
    … …  
    39723972        paPhysExts[iPhysExt].aidx[2] = iShwPT;
    39733973        paPhysExts[iPhysExt].apte[2] = iPte;
    3974         STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->StatTrackAliasedMany);
     3974        STAM_COUNTER_INC(&pVM->pgm.s.Stats.StatTrackAliasedMany);
    39753975        LogFlow(("pgmPoolTrackPhysExtInsert: %d:{,,%d pte %d}\n", iPhysExt, iShwPT, iPte));
    39763976        return PGMPOOL_TD_MAKE(PGMPOOL_TD_CREFS_PHYSEXT, iPhysExt);
    … …  
    39913991                paPhysExts[iPhysExt].aidx[i] = iShwPT;
    39923992                paPhysExts[iPhysExt].apte[i] = iPte;
    3993                 STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->StatTrackAliasedMany);
     3993                STAM_COUNTER_INC(&pVM->pgm.s.Stats.StatTrackAliasedMany);
    39943994                LogFlow(("pgmPoolTrackPhysExtInsert: %d:{%d pte %d} i=%d cMax=%d\n", iPhysExt, iShwPT, iPte, i, cMax));
    39953995                return PGMPOOL_TD_MAKE(PGMPOOL_TD_CREFS_PHYSEXT, iPhysExtStart);
    … …  
    39973997        if (!--cMax)
    39983998        {
    3999             STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->StatTrackOverflows);
     3999            STAM_COUNTER_INC(&pVM->pgm.s.Stats.StatTrackOverflows);
    40004000            pgmPoolTrackPhysExtFreeList(pVM, iPhysExtStart);
    40014001            LogFlow(("pgmPoolTrackPhysExtInsert: overflow (1) iShwPT=%d\n", iShwPT));
    … …  
    40154015    if (!pNew)
    40164016    {
    4017         STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->StatTrackNoExtentsLeft);
     4017        STAM_COUNTER_INC(&pVM->pgm.s.Stats.StatTrackNoExtentsLeft);
    40184018        pgmPoolTrackPhysExtFreeList(pVM, iPhysExtStart);
    40194019        LogFlow(("pgmPoolTrackPhysExtInsert: pgmPoolTrackPhysExtAlloc failed iShwPT=%d\n", iShwPT));
    … …  
    40534053        {
    40544054            LogFlow(("pgmPoolTrackPhysExtAddref: new extent: %d:{%d, %d}\n", iPhysExt, PGMPOOL_TD_GET_IDX(u16), iShwPT));
    4055             STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->StatTrackAliased);
     4055            STAM_COUNTER_INC(&pVM->pgm.s.Stats.StatTrackAliased);
    40564056            pPhysExt->aidx[0] = PGMPOOL_TD_GET_IDX(u16);
    40574057            pPhysExt->apte[0] = PGM_PAGE_GET_PTE_INDEX(pPhysPage);
    … …  
    40714071    }
    40724072    else
    4073         STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->StatTrackAliasedLots);
     4073        STAM_COUNTER_INC(&pVM->pgm.s.Stats.StatTrackAliasedLots);
    40744074    PGM_UNLOCK(pVM);
    40754075    return u16;

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

    r91016 r91247  
    617617        {
    618618            if (uErr & X86_TRAP_PF_RW)
    619                 STAM_COUNTER_INC(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eUSNotPresentWrite);
     619                STAM_COUNTER_INC(&pGVCpu->pgm.s.Stats.StatRZTrap0eUSNotPresentWrite);
    620620            else
    621                 STAM_COUNTER_INC(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eUSNotPresentRead);
     621                STAM_COUNTER_INC(&pGVCpu->pgm.s.Stats.StatRZTrap0eUSNotPresentRead);
    622622        }
    623623        else if (uErr & X86_TRAP_PF_RW)
    624             STAM_COUNTER_INC(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eUSWrite);
     624            STAM_COUNTER_INC(&pGVCpu->pgm.s.Stats.StatRZTrap0eUSWrite);
    625625        else if (uErr & X86_TRAP_PF_RSVD)
    626             STAM_COUNTER_INC(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eUSReserved);
     626            STAM_COUNTER_INC(&pGVCpu->pgm.s.Stats.StatRZTrap0eUSReserved);
    627627        else if (uErr & X86_TRAP_PF_ID)
    628             STAM_COUNTER_INC(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eUSNXE);
     628            STAM_COUNTER_INC(&pGVCpu->pgm.s.Stats.StatRZTrap0eUSNXE);
    629629        else
    630             STAM_COUNTER_INC(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eUSRead);
     630            STAM_COUNTER_INC(&pGVCpu->pgm.s.Stats.StatRZTrap0eUSRead);
    631631    }
    632632    else
    … …  
    635635        {
    636636            if (uErr & X86_TRAP_PF_RW)
    637                 STAM_COUNTER_INC(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eSVNotPresentWrite);
     637                STAM_COUNTER_INC(&pGVCpu->pgm.s.Stats.StatRZTrap0eSVNotPresentWrite);
    638638            else
    639                 STAM_COUNTER_INC(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eSVNotPresentRead);
     639                STAM_COUNTER_INC(&pGVCpu->pgm.s.Stats.StatRZTrap0eSVNotPresentRead);
    640640        }
    641641        else if (uErr & X86_TRAP_PF_RW)
    642             STAM_COUNTER_INC(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eSVWrite);
     642            STAM_COUNTER_INC(&pGVCpu->pgm.s.Stats.StatRZTrap0eSVWrite);
    643643        else if (uErr & X86_TRAP_PF_ID)
    644             STAM_COUNTER_INC(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eSNXE);
     644            STAM_COUNTER_INC(&pGVCpu->pgm.s.Stats.StatRZTrap0eSNXE);
    645645        else if (uErr & X86_TRAP_PF_RSVD)
    646             STAM_COUNTER_INC(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eSVReserved);
     646            STAM_COUNTER_INC(&pGVCpu->pgm.s.Stats.StatRZTrap0eSVReserved);
    647647    }
    648648#endif
    … …  
    701701
    702702    STAM_STATS({ if (!pGVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution))
    703                     pGVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pGVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2Misc; });
    704     STAM_PROFILE_STOP_EX(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0e, pGVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution), a);
     703                    pGVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pGVCpu->pgm.s.Stats.StatRZTrap0eTime2Misc; });
     704    STAM_PROFILE_STOP_EX(&pGVCpu->pgm.s.Stats.StatRZTrap0e, pGVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution), a);
    705705    return rc;
    706706}
    … …  
    749749        {
    750750            Log(("PGMR0Trap0eHandlerNPMisconfig: Resyncing aliases / tmp-off page at %RGp (uErr=%#x) %R[pgmpage]\n", GCPhysFault, uErr, pPage));
    751             STAM_COUNTER_INC(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatR0NpMiscfgSyncPage);
     751            STAM_COUNTER_INC(&pGVCpu->pgm.s.Stats.StatR0NpMiscfgSyncPage);
    752752            rc = pgmShwSyncNestedPageLocked(pGVCpu, GCPhysFault, 1 /*cPages*/, enmShwPagingMode);
    753753            PGM_UNLOCK(pGVM);
    … …  
    790790         */
    791791        Log(("PGMR0Trap0eHandlerNPMisconfig: Out of sync page at %RGp (uErr=%#x)\n", GCPhysFault, uErr));
    792         STAM_COUNTER_INC(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatR0NpMiscfgSyncPage);
     792        STAM_COUNTER_INC(&pGVCpu->pgm.s.Stats.StatR0NpMiscfgSyncPage);
    793793        rc = pgmShwSyncNestedPageLocked(pGVCpu, GCPhysFault, 1 /*cPages*/, enmShwPagingMode);
    794794        PGM_UNLOCK(pGVM);
    795795    }
    796796
    797     STAM_PROFILE_STOP(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatR0NpMiscfg, a);
     797    STAM_PROFILE_STOP(&pGVCpu->pgm.s.Stats.StatR0NpMiscfg, a);
    798798    return rc;
    799799

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

    r91246 r91247  
    874874    rc = CFGMR3QueryBoolDef(pCfgPGM, "ZeroRamPagesOnReset", &pVM->pgm.s.fZeroRamPagesOnReset, true);
    875875    AssertLogRelRCReturn(rc, rc);
    876 
    877 #ifdef VBOX_WITH_STATISTICS
    878     /*
    879      * Allocate memory for the statistics before someone tries to use them.
    880      */
    881     size_t cbTotalStats = RT_ALIGN_Z(sizeof(PGMSTATS), 64) + RT_ALIGN_Z(sizeof(PGMCPUSTATS), 64) * pVM->cCpus;
    882     void *pv;
    883     rc = MMHyperAlloc(pVM, RT_ALIGN_Z(cbTotalStats, PAGE_SIZE), PAGE_SIZE, MM_TAG_PGM, &pv);
    884     AssertRCReturn(rc, rc);
    885 
    886     pVM->pgm.s.pStatsR3 = (PGMSTATS *)pv;
    887     pVM->pgm.s.pStatsR0 = MMHyperCCToR0(pVM, pv);
    888     pv = (uint8_t *)pv + RT_ALIGN_Z(sizeof(PGMSTATS), 64);
    889 
    890     for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
    891     {
    892         PVMCPU pVCpu = pVM->apCpusR3[idCpu];
    893         pVCpu->pgm.s.pStatsR3 = (PGMCPUSTATS *)pv;
    894         pVCpu->pgm.s.pStatsR0 = MMHyperCCToR0(pVM, pv);
    895 
    896         pv = (uint8_t *)pv + RT_ALIGN_Z(sizeof(PGMCPUSTATS), 64);
    897     }
    898 #endif /* VBOX_WITH_STATISTICS */
    899876
    900877    /*
    … …  
    13081285        AssertRC(rc);
    13091286
    1310     PGMSTATS *pStats = pVM->pgm.s.pStatsR3;
     1287    PGMSTATS *pStats = &pVM->pgm.s.Stats;
    13111288
    13121289    PGM_REG_PROFILE(&pStats->StatAllocLargePage,                "/PGM/LargePage/Alloc",               "Time spent by the host OS for large page allocation.");
    … …  
    14181395
    14191396#ifdef VBOX_WITH_STATISTICS
    1420         PGMCPUSTATS *pCpuStats = pVM->apCpusR3[idCpu]->pgm.s.pStatsR3;
     1397        PGMCPUSTATS *pCpuStats = &pVM->apCpusR3[idCpu]->pgm.s.Stats;
    14211398
    14221399# if 0 /* rarely useful; leave for debugging. */

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

    r90439 r91247  
    11711171{
    11721172    STAM_REL_COUNTER_INC(&pVM->pgm.s.cRelocations);
    1173     STAM_PROFILE_START(&pVM->pgm.s.CTX_SUFF(pStats)->StatR3ResolveConflict, a);
     1173    STAM_PROFILE_START(&pVM->pgm.s.Stats.StatR3ResolveConflict, a);
    11741174
    11751175    /* Raw mode only which implies one VCPU. */
    … …  
    12241224        {
    12251225            pgmR3MapRelocate(pVM, pMapping, GCPtrOldMapping, GCPtrNewMapping);
    1226             STAM_PROFILE_STOP(&pVM->pgm.s.CTX_SUFF(pStats)->StatR3ResolveConflict, a);
     1226            STAM_PROFILE_STOP(&pVM->pgm.s.Stats.StatR3ResolveConflict, a);
    12271227            return VINF_SUCCESS;
    12281228        }
    12291229    }
    12301230
    1231     STAM_PROFILE_STOP(&pVM->pgm.s.CTX_SUFF(pStats)->StatR3ResolveConflict, a);
     1231    STAM_PROFILE_STOP(&pVM->pgm.s.Stats.StatR3ResolveConflict, a);
    12321232# ifdef DEBUG_bird
    12331233    /*
    … …  
    13321332            {
    13331333                pgmR3MapRelocate(pVM, pMapping, GCPtrOldMapping, GCPtrNewMapping);
    1334                 STAM_PROFILE_STOP(&pVM->pgm.s.CTX_SUFF(pStats)->StatR3ResolveConflict, a);
     1334                STAM_PROFILE_STOP(&pVM->pgm.s.Stats.StatR3ResolveConflict, a);
    13351335                return VINF_SUCCESS;
    13361336            }
    13371337        }
    13381338    }
    1339     STAM_PROFILE_STOP(&pVM->pgm.s.CTX_SUFF(pStats)->StatR3ResolveConflict, a);
     1339    STAM_PROFILE_STOP(&pVM->pgm.s.Stats.StatR3ResolveConflict, a);
    13401340    AssertMsgFailed(("Failed to relocate page table mapping '%s' from %#x! (cPTs=%d)\n", pMapping->pszDesc, GCPtrOldMapping, pMapping->cb >> X86_PD_PAE_SHIFT));
    13411341    return VERR_PGM_NO_HYPERVISOR_ADDRESS;

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

    r91246 r91247  
    46654665     * Enumerate the age tree starting with the left most node.
    46664666     */
    4667     STAM_PROFILE_START(&pVM->pgm.s.CTX_SUFF(pStats)->StatChunkFindCandidate, a);
     4667    STAM_PROFILE_START(&pVM->pgm.s.Stats.StatChunkFindCandidate, a);
    46684668    PGMR3PHYSCHUNKUNMAPCB Args;
    46694669    Args.pVM    = pVM;
    … …  
    46754675        Assert(Args.pChunk->cRefs == 0);
    46764676        Assert(Args.pChunk->cPermRefs == 0);
    4677         STAM_PROFILE_STOP(&pVM->pgm.s.CTX_SUFF(pStats)->StatChunkFindCandidate, a);
     4677        STAM_PROFILE_STOP(&pVM->pgm.s.Stats.StatChunkFindCandidate, a);
    46784678        return Args.pChunk->Core.Key;
    46794679    }
    46804680
    4681     STAM_PROFILE_STOP(&pVM->pgm.s.CTX_SUFF(pStats)->StatChunkFindCandidate, a);
     4681    STAM_PROFILE_STOP(&pVM->pgm.s.Stats.StatChunkFindCandidate, a);
    46824682    return INT32_MAX;
    46834683}
    … …  
    47204720        if (Req.idChunkUnmap != INT32_MAX)
    47214721        {
    4722             STAM_PROFILE_START(&pVM->pgm.s.CTX_SUFF(pStats)->StatChunkUnmap, a);
     4722            STAM_PROFILE_START(&pVM->pgm.s.Stats.StatChunkUnmap, a);
    47234723            rc = VMMR3CallR0(pVM, VMMR0_DO_GMM_MAP_UNMAP_CHUNK, 0, &Req.Hdr);
    4724             STAM_PROFILE_STOP(&pVM->pgm.s.CTX_SUFF(pStats)->StatChunkUnmap, a);
     4724            STAM_PROFILE_STOP(&pVM->pgm.s.Stats.StatChunkUnmap, a);
    47254725            if (RT_SUCCESS(rc))
    47264726            {
    … …  
    48294829
    48304830    /* Must be callable from any thread, so can't use VMMR3CallR0. */
    4831     STAM_PROFILE_START(&pVM->pgm.s.CTX_SUFF(pStats)->StatChunkMap, a);
     4831    STAM_PROFILE_START(&pVM->pgm.s.Stats.StatChunkMap, a);
    48324832    rc = SUPR3CallVMMR0Ex(VMCC_GET_VMR0_FOR_CALL(pVM), NIL_VMCPUID, VMMR0_DO_GMM_MAP_UNMAP_CHUNK, 0, &Req.Hdr);
    4833     STAM_PROFILE_STOP(&pVM->pgm.s.CTX_SUFF(pStats)->StatChunkMap, a);
     4833    STAM_PROFILE_STOP(&pVM->pgm.s.Stats.StatChunkMap, a);
    48344834    if (RT_SUCCESS(rc))
    48354835    {
    … …  
    49354935    PGM_LOCK_VOID(pVM);
    49364936
    4937     STAM_PROFILE_START(&pVM->pgm.s.CTX_SUFF(pStats)->StatAllocLargePage, a);
     4937    STAM_PROFILE_START(&pVM->pgm.s.Stats.StatAllocLargePage, a);
    49384938    uint64_t const msAllocStart = RTTimeMilliTS();
    49394939    int rc = VMMR3CallR0(pVM, VMMR0_DO_PGM_ALLOCATE_LARGE_HANDY_PAGE, 0, NULL);
    49404940    uint64_t const cMsElapsed   = RTTimeMilliTS() - msAllocStart;
    4941     STAM_PROFILE_STOP(&pVM->pgm.s.CTX_SUFF(pStats)->StatAllocLargePage, a);
     4941    STAM_PROFILE_STOP(&pVM->pgm.s.Stats.StatAllocLargePage, a);
    49424942    if (RT_SUCCESS(rc))
    49434943    {
    … …  
    49644964             * Clear the pages.
    49654965             */
    4966             STAM_PROFILE_START(&pVM->pgm.s.CTX_SUFF(pStats)->StatClearLargePage, b);
     4966            STAM_PROFILE_START(&pVM->pgm.s.Stats.StatClearLargePage, b);
    49674967            for (unsigned i = 0; i < _2M/PAGE_SIZE; i++)
    49684968            {
    … …  
    49744974
    49754975                Assert(PGM_PAGE_IS_ZERO(pPage));
    4976                 STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->StatRZPageReplaceZero);
     4976                STAM_COUNTER_INC(&pVM->pgm.s.Stats.StatRZPageReplaceZero);
    49774977                pVM->pgm.s.cZeroPages--;
    49784978
    … …  
    49984998                Log3(("PGMR3PhysAllocateLargePage: idPage=%#x HCPhys=%RGp\n", idPage, HCPhys));
    49994999            }
    5000             STAM_PROFILE_STOP(&pVM->pgm.s.CTX_SUFF(pStats)->StatClearLargePage, b);
     5000            STAM_PROFILE_STOP(&pVM->pgm.s.Stats.StatClearLargePage, b);
    50015001
    50025002            /* Flush all TLBs. */
    … …  
    50125012        if (cMsElapsed > 100)
    50135013        {
    5014             STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->StatLargePageOverflow);
     5014            STAM_COUNTER_INC(&pVM->pgm.s.Stats.StatLargePageOverflow);
    50155015            if (   ++cTimeOut > 10
    50165016                || cMsElapsed > 1000 /* more than one second forces an early retirement from allocating large pages. */)

  • trunk/src/VBox/VMM/include/PGMInline.h

    r91014 r91247  
    6464    if (!pRam || GCPhys - pRam->GCPhys >= pRam->cb)
    6565        return pgmPhysGetRangeSlow(pVM, GCPhys);
    66     STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,RamRangeTlbHits));
     66    STAM_COUNTER_INC(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,RamRangeTlbHits));
    6767    return pRam;
    6868}
    … …  
    8585        || (GCPhys - pRam->GCPhys) >= pRam->cb)
    8686        return pgmPhysGetRangeAtOrAboveSlow(pVM, GCPhys);
    87     STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,RamRangeTlbHits));
     87    STAM_COUNTER_INC(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,RamRangeTlbHits));
    8888    return pRam;
    8989}
    … …  
    106106        || (off = GCPhys - pRam->GCPhys) >= pRam->cb)
    107107        return pgmPhysGetPageSlow(pVM, GCPhys);
    108     STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,RamRangeTlbHits));
     108    STAM_COUNTER_INC(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,RamRangeTlbHits));
    109109    return &pRam->aPages[off >> PAGE_SHIFT];
    110110}
    … …  
    132132        return pgmPhysGetPageExSlow(pVM, GCPhys, ppPage);
    133133    *ppPage = &pRam->aPages[off >> PAGE_SHIFT];
    134     STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,RamRangeTlbHits));
     134    STAM_COUNTER_INC(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,RamRangeTlbHits));
    135135    return VINF_SUCCESS;
    136136}
    … …  
    164164            return pgmPhysGetPageAndRangeExSlow(pVM, GCPhys, ppPage, ppRamHint);
    165165
    166         STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,RamRangeTlbHits));
     166        STAM_COUNTER_INC(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,RamRangeTlbHits));
    167167        *ppRamHint = pRam;
    168168    }
    … …  
    191191        return pgmPhysGetPageAndRangeExSlow(pVM, GCPhys, ppPage, ppRam);
    192192
    193     STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,RamRangeTlbHits));
     193    STAM_COUNTER_INC(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,RamRangeTlbHits));
    194194    *ppRam = pRam;
    195195    *ppPage = &pRam->aPages[off >> PAGE_SHIFT];
    … …  
    238238    if (pTlbe->GCPhys == (GCPhys & X86_PTE_PAE_PG_MASK))
    239239    {
    240         STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PageMapTlbHits));
     240        STAM_COUNTER_INC(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,PageMapTlbHits));
    241241        rc = VINF_SUCCESS;
    242242    }
    … …  
    268268    if (pTlbe->GCPhys == (GCPhys & X86_PTE_PAE_PG_MASK))
    269269    {
    270         STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PageMapTlbHits));
     270        STAM_COUNTER_INC(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,PageMapTlbHits));
    271271        rc = VINF_SUCCESS;
    272272        AssertPtr(pTlbe->pv);
    … …  
    916916        && GCPhys < pHandler->Core.KeyLast)
    917917    {
    918         STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PhysHandlerLookupHits));
     918        STAM_COUNTER_INC(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,PhysHandlerLookupHits));
    919919        return pHandler;
    920920    }
    921921
    922     STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PhysHandlerLookupMisses));
     922    STAM_COUNTER_INC(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,PhysHandlerLookupMisses));
    923923    pHandler = (PPGMPHYSHANDLER)RTAvlroGCPhysRangeGet(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, GCPhys);
    924924    if (pHandler)

  • trunk/src/VBox/VMM/include/PGMInternal.h

    r91016 r91247  
    28182818/**
    28192819 * PGM statistics.
    2820  *
    2821  * These lives on the heap when compiled in as they would otherwise waste
    2822  * unnecessary space in release builds.
    28232820 */
    28242821typedef struct PGMSTATS
    … …  
    28952892
    28962893    /** Time spent by the host OS for large page allocation. */
    2897     STAMPROFILE                 StatAllocLargePage;
     2894    STAMPROFILE StatAllocLargePage;
    28982895    /** Time spent clearing the newly allocated large pages. */
    2899     STAMPROFILE                 StatClearLargePage;
     2896    STAMPROFILE StatClearLargePage;
    29002897    /** The number of times allocating a large pages takes more than the allowed period. */
    2901     STAMCOUNTER                 StatLargePageOverflow;
     2898    STAMCOUNTER StatLargePageOverflow;
    29022899    /** pgmPhysIsValidLargePage profiling - R3 */
    2903     STAMPROFILE                 StatR3IsValidLargePage;
     2900    STAMPROFILE StatR3IsValidLargePage;
    29042901    /** pgmPhysIsValidLargePage profiling - RZ*/
    2905     STAMPROFILE                 StatRZIsValidLargePage;
    2906 
    2907     STAMPROFILE                 StatChunkAging;
    2908     STAMPROFILE                 StatChunkFindCandidate;
    2909     STAMPROFILE                 StatChunkUnmap;
    2910     STAMPROFILE                 StatChunkMap;
     2902    STAMPROFILE StatRZIsValidLargePage;
     2903
     2904    STAMPROFILE StatChunkAging;
     2905    STAMPROFILE StatChunkFindCandidate;
     2906    STAMPROFILE StatChunkUnmap;
     2907    STAMPROFILE StatChunkMap;
    29112908} PGMSTATS;
    29122909#endif /* VBOX_WITH_STATISTICS */
    … …  
    32843281    /** @} */
    32853282
    3286 #ifdef VBOX_WITH_STATISTICS
    3287     /** @name Statistics on the heap.
    3288      * @{ */
    3289     R3PTRTYPE(PGMSTATS *)           pStatsR3;
    3290     R0PTRTYPE(PGMSTATS *)           pStatsR0;
    3291     /** @} */
    3292 #endif
     3283    /** These are optional statistics that used to be on the hyper heap. */
     3284    PGMSTATS                        Stats;
    32933285} PGM;
    32943286#ifndef IN_TSTVMSTRUCTGC /* HACK */
    … …  
    36673659    /** @} */
    36683660
    3669 #ifdef VBOX_WITH_STATISTICS /** @todo move this chunk to the heap. */
    36703661    /** @name Statistics
    36713662     * @{ */
    3672     /** R0: Pointer to the statistics. */
    3673     R0PTRTYPE(PGMCPUSTATS *)        pStatsR0;
    36743663    /** R0: Which statistic this \#PF should be attributed to. */
    36753664    R0PTRTYPE(PSTAMPROFILE)         pStatTrap0eAttributionR0;
    3676     /** R3: Pointer to the statistics. */
    3677     R3PTRTYPE(PGMCPUSTATS *)        pStatsR3;
    3678     /** Alignment padding. */
    3679     RTR3PTR                         pPaddingR3;
     3665    /** These are statistics that used to be on the hyper heap. */
     3666    PGMCPUSTATS                     Stats;
    36803667    /** @} */
    3681 #endif /* VBOX_WITH_STATISTICS */
    36823668} PGMCPU;
    36833669/** Pointer to the per-cpu PGM data. */
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