VirtualBox

Changeset 22885 in vbox


Ignore:
Timestamp:
Sep 9, 2009 9:58:49 PM (15 years ago)
Author:
vboxsync
Message:

VMM: Realigned VM and VMCPU members for 64 byte cache lines. Made VMCPU and VM::aCpus page aligned for potentially increasing the TLB efficiency. (This is expected to burn on 64-bit hosts.)

Location:
trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/vm.h

    r22789 r22885  
    134134        struct PGMCPU       s;
    135135#endif
    136         char                padding[32*1024];   /* multiple of 64 */
     136        char                padding[28*1024];   /* multiple of 64 */
    137137    } pgm;
    138138
    … …  
    143143        struct HWACCMCPU    s;
    144144#endif
    145         char                padding[6144];      /* multiple of 64 */
     145        char                padding[5248];      /* multiple of 64 */
    146146    } hwaccm;
    147147
    … …  
    152152        struct EMCPU        s;
    153153#endif
    154         char                padding[2048];      /* multiple of 64 */
     154        char                padding[1280];      /* multiple of 64 */
    155155    } em;
    156156
    … …  
    179179        struct VMMCPU       s;
    180180#endif
    181         char                padding[384];       /* multiple of 64 */
     181        char                padding[256];       /* multiple of 64 */
    182182    } vmm;
    183183
    … …  
    210210    } dbgf;
    211211
     212    /** Align at page boundrary. */
     213    uint8_t                 abReserved[HC_ARCH_BITS == 32 ? 448 : 64];
    212214} VMCPU;
    213215
    … …  
    716718     * @remark  Assume interrupts disabled.
    717719     */
    718     RTRCPTR             pfnVMMGCGuestToHostAsmGuestCtx/*(int32_t eax, CPUMCTXCORE Ctx)*/;
     720    RTRCPTR                     pfnVMMGCGuestToHostAsmGuestCtx/*(int32_t eax, CPUMCTXCORE Ctx)*/;
    719721
    720722    /**
    … …  
    731733     * @remark  Assume interrupts disabled.
    732734     */
    733     RTRCPTR             pfnVMMGCGuestToHostAsmHyperCtx/*(int32_t eax, PCPUMCTXCORE ecx)*/;
     735    RTRCPTR                     pfnVMMGCGuestToHostAsmHyperCtx/*(int32_t eax, PCPUMCTXCORE ecx)*/;
    734736
    735737    /**
    … …  
    743745     * @remark  Assume interrupts disabled.
    744746     */
    745     RTRCPTR             pfnVMMGCGuestToHostAsm/*(int32_t eax)*/;
     747    RTRCPTR                     pfnVMMGCGuestToHostAsm/*(int32_t eax)*/;
    746748    /** @} */
    747749
    … …  
    749751    /** @name Various VM data owned by VM.
    750752     * @{ */
    751     RTTHREAD            uPadding1;
     753    RTTHREAD                    uPadding1;
    752754    /** The native handle of ThreadEMT. Getting the native handle
    753755     * is generally faster than getting the IPRT one (except on OS/2 :-). */
    754     RTNATIVETHREAD      uPadding2;
     756    RTNATIVETHREAD              uPadding2;
    755757    /** @} */
    756758
    … …  
    759761     * @{ */
    760762    /** Raw ring-3 indicator.  */
    761     bool                fRawR3Enabled;
     763    bool                        fRawR3Enabled;
    762764    /** Raw ring-0 indicator. */
    763     bool                fRawR0Enabled;
     765    bool                        fRawR0Enabled;
    764766    /** PATM enabled flag.
    765767     * This is placed here for performance reasons. */
    766     bool                fPATMEnabled;
     768    bool                        fPATMEnabled;
    767769    /** CSAM enabled flag.
    768770     * This is placed here for performance reasons. */
    769     bool                fCSAMEnabled;
     771    bool                        fCSAMEnabled;
    770772    /** Hardware VM support is available and enabled.
    771773     * This is placed here for performance reasons. */
    772     bool                fHWACCMEnabled;
     774    bool                        fHWACCMEnabled;
    773775    /** Hardware VM support is required and non-optional.
    774776     * This is initialized together with the rest of the VM structure. */
    775     bool                fHwVirtExtForced;
     777    bool                        fHwVirtExtForced;
    776778    /** PARAV enabled flag. */
    777     bool                fPARAVEnabled;
     779    bool                        fPARAVEnabled;
    778780    /** @} */
    779781
    … …  
    781783    /* padding to make gnuc put the StatQemuToGC where msc does. */
    782784#if HC_ARCH_BITS == 32
    783     uint32_t            padding0;
     785    uint32_t                    padding0;
    784786#endif
    785787
    786788    /** Profiling the total time from Qemu to GC. */
    787     STAMPROFILEADV      StatTotalQemuToGC;
     789    STAMPROFILEADV              StatTotalQemuToGC;
    788790    /** Profiling the total time from GC to Qemu. */
    789     STAMPROFILEADV      StatTotalGCToQemu;
     791    STAMPROFILEADV              StatTotalGCToQemu;
    790792    /** Profiling the total time spent in GC. */
    791     STAMPROFILEADV      StatTotalInGC;
     793    STAMPROFILEADV              StatTotalInGC;
    792794    /** Profiling the total time spent not in Qemu. */
    793     STAMPROFILEADV      StatTotalInQemu;
     795    STAMPROFILEADV              StatTotalInQemu;
    794796    /** Profiling the VMMSwitcher code for going to GC. */
    795     STAMPROFILEADV      StatSwitcherToGC;
     797    STAMPROFILEADV              StatSwitcherToGC;
    796798    /** Profiling the VMMSwitcher code for going to HC. */
    797     STAMPROFILEADV      StatSwitcherToHC;
    798     STAMPROFILEADV      StatSwitcherSaveRegs;
    799     STAMPROFILEADV      StatSwitcherSysEnter;
    800     STAMPROFILEADV      StatSwitcherDebug;
    801     STAMPROFILEADV      StatSwitcherCR0;
    802     STAMPROFILEADV      StatSwitcherCR4;
    803     STAMPROFILEADV      StatSwitcherJmpCR3;
    804     STAMPROFILEADV      StatSwitcherRstrRegs;
    805     STAMPROFILEADV      StatSwitcherLgdt;
    806     STAMPROFILEADV      StatSwitcherLidt;
    807     STAMPROFILEADV      StatSwitcherLldt;
    808     STAMPROFILEADV      StatSwitcherTSS;
     799    STAMPROFILEADV              StatSwitcherToHC;
     800    STAMPROFILEADV              StatSwitcherSaveRegs;
     801    STAMPROFILEADV              StatSwitcherSysEnter;
     802    STAMPROFILEADV              StatSwitcherDebug;
     803    STAMPROFILEADV              StatSwitcherCR0;
     804    STAMPROFILEADV              StatSwitcherCR4;
     805    STAMPROFILEADV              StatSwitcherJmpCR3;
     806    STAMPROFILEADV              StatSwitcherRstrRegs;
     807    STAMPROFILEADV              StatSwitcherLgdt;
     808    STAMPROFILEADV              StatSwitcherLidt;
     809    STAMPROFILEADV              StatSwitcherLldt;
     810    STAMPROFILEADV              StatSwitcherTSS;
    809811
    810812/** @todo Realign everything on 64 byte boundaries to better match the
    811813 *        cache-line size. */
    812814    /* padding - the unions must be aligned on 32 bytes boundraries. */
    813     uint32_t            padding[HC_ARCH_BITS == 32 ? 4+8 : 6];
     815    uint32_t                padding[HC_ARCH_BITS == 32 ? 4+8 : 6];
    814816
    815817    /** CPUM part. */
    … …  
    819821        struct CPUM s;
    820822#endif
    821         char        padding[2048];        /* multiple of 32 */
     823        uint8_t     padding[1472];      /* multiple of 64 */
    822824    } cpum;
    823825
    … …  
    828830        struct VMM  s;
    829831#endif
    830         char        padding[1600];       /* multiple of 32 */
     832        uint8_t     padding[1536];      /* multiple of 64 */
    831833    } vmm;
    832834
    … …  
    837839        struct PGM  s;
    838840#endif
    839         char        padding[16*1024];   /* multiple of 32 */
     841        uint8_t     padding[5184];      /* multiple of 64 */
    840842    } pgm;
    841843
    … …  
    846848        struct HWACCM s;
    847849#endif
    848         char        padding[8192];       /* multiple of 32 */
     850        uint8_t     padding[5376];      /* multiple of 64 */
    849851    } hwaccm;
    850852
    … …  
    855857        struct TRPM s;
    856858#endif
    857         char        padding[5344];      /* multiple of 32 */
     859        uint8_t     padding[5184];      /* multiple of 64 */
    858860    } trpm;
    859861
    … …  
    864866        struct SELM s;
    865867#endif
    866         char        padding[544];      /* multiple of 32 */
     868        uint8_t     padding[576];       /* multiple of 64 */
    867869    } selm;
    868870
    … …  
    873875        struct MM   s;
    874876#endif
    875         char        padding[192];       /* multiple of 32 */
     877        uint8_t     padding[192];       /* multiple of 64 */
    876878    } mm;
    877 
    878     /** CFGM part. */
    879     union
    880     {
    881 #ifdef ___CFGMInternal_h
    882         struct CFGM s;
    883 #endif
    884         char        padding[32];        /* multiple of 32 */
    885     } cfgm;
    886879
    887880    /** PDM part. */
    … …  
    891884        struct PDM s;
    892885#endif
    893         char        padding[1824];      /* multiple of 32 */
     886        uint8_t     padding[1024];      /* multiple of 64 */
    894887    } pdm;
    895888
    … …  
    900893        struct IOM s;
    901894#endif
    902         char        padding[4544];      /* multiple of 32 */
     895        uint8_t     padding[768];       /* multiple of 64 */
    903896    } iom;
    904897
    … …  
    909902        struct PATM s;
    910903#endif
    911         char        padding[768];       /* multiple of 32 */
     904        uint8_t     padding[768];       /* multiple of 64 */
    912905    } patm;
    913906
    … …  
    918911        struct CSAM s;
    919912#endif
    920         char        padding[3328];    /* multiple of 32 */
     913        uint8_t     padding[1024];      /* multiple of 64 */
    921914    } csam;
    922 
    923     /** PARAV part. */
    924     union
    925     {
    926 #ifdef ___PARAVInternal_h
    927         struct PARAV s;
    928 #endif
    929         char        padding[128];
    930     } parav;
    931915
    932916    /** EM part. */
    … …  
    936920        struct EM   s;
    937921#endif
    938         char        padding[256];         /* multiple of 32 */
     922        uint8_t     padding[256];       /* multiple of 64 */
    939923    } em;
    940924
    … …  
    945929        struct TM   s;
    946930#endif
    947         char        padding[2112];      /* multiple of 32 */
     931        uint8_t     padding[2112];      /* multiple of 64 */
    948932    } tm;
    949933
    … …  
    954938        struct DBGF s;
    955939#endif
    956         char        padding[2368];      /* multiple of 32 */
     940        uint8_t     padding[2368];      /* multiple of 64 */
    957941    } dbgf;
    958942
    … …  
    963947        struct SSM  s;
    964948#endif
    965         char        padding[32];        /* multiple of 32 */
     949        uint8_t     padding[64];        /* multiple of 64 */
    966950    } ssm;
    967 
    968     /** VM part. */
    969     union
    970     {
    971 #ifdef ___VMInternal_h
    972         struct VMINT    s;
    973 #endif
    974         char        padding[768];       /* multiple of 32 */
    975     } vm;
    976951
    977952    /** REM part. */
    … …  
    985960 * Must be multiple of 32 and coherent with REM_ENV_SIZE from REMInternal.h. */
    986961# define VM_REM_SIZE        0x11100
    987         char        padding[VM_REM_SIZE];   /* multiple of 32 */
     962        uint8_t     padding[VM_REM_SIZE];   /* multiple of 32 */
    988963    } rem;
    989964
     965    /* ---- begin small stuff ---- */
     966
     967    /** VM part. */
     968    union
     969    {
     970#ifdef ___VMInternal_h
     971        struct VMINT    s;
     972#endif
     973        uint8_t     padding[24];        /* multiple of 8 */
     974    } vm;
     975
     976    /** PARAV part. */
     977    union
     978    {
     979#ifdef ___PARAVInternal_h
     980        struct PARAV s;
     981#endif
     982        uint8_t     padding[24];        /* multiple of 8 */
     983    } parav;
     984
     985    /** CFGM part. */
     986    union
     987    {
     988#ifdef ___CFGMInternal_h
     989        struct CFGM s;
     990#endif
     991        uint8_t     padding[8];         /* multiple of 8 */
     992    } cfgm;
     993
    990994    /** Padding for aligning the cpu array on a 64 byte boundrary. */
    991     uint32_t    u32Reserved2[8];
     995    uint8_t         abReserved2[8 + (HC_ARCH_BITS == 32 ? 3712 : 0)];
     996
     997    /* ---- end small stuff ---- */
    992998
    993999    /** VMCPU array for the configured number of virtual CPUs.
    994      * Must be aligned on a 64-byte boundrary.  */
    995     VMCPU       aCpus[1];
     1000     * Must be aligned on a page boundrary for TLB hit reasons as well as
     1001     * alignment of VMCPU members. */
     1002    VMCPU           aCpus[1];
    9961003} VM;
    9971004

  • trunk/include/VBox/vm.mac

    r22042 r22885  
    9797
    9898    alignb 64
    99     .cpum                   resb 2048
    100     .vmm                    resb 1024
     99    .cpum                   resb 1472
     100    .vmm                    resb 1536
    101101
    102102endstruc

  • trunk/src/VBox/Devices/testcase/tstDeviceStructSize.cpp

    r21232 r22885  
    134134    do \
    135135    { \
    136         if ( RT_OFFSETOF(strct, member) & ((align) - 1) ) \
    137         { \
    138             printf("%s::%s offset=%d expected alignment %d, meaning %d off\n", #strct, #member, RT_OFFSETOF(strct, member), \
    139                    align, RT_OFFSETOF(strct, member) & (align - 1)); \
     136        if (RT_OFFSETOF(strct, member) & ((align) - 1) ) \
     137        { \
     138            printf("%s::%s offset=%#x (%u) expected alignment %x, meaning %#x (%u) off\n", \
     139                   #strct, #member, \
     140                   (unsigned)RT_OFFSETOF(strct, member), \
     141                   (unsigned)RT_OFFSETOF(strct, member), \
     142                   (unsigned)(align), \
     143                   (unsigned)((align) - RT_OFFSETOF(strct, member) & ((align) - 1)), \
     144                   (unsigned)((align) - RT_OFFSETOF(strct, member) & ((align) - 1)) ); \
    140145            rc++; \
    141146        } \
    … …  
    149154        if (RT_ALIGN_Z(sizeof(type), (align)) != sizeof(type)) \
    150155        { \
    151             printf("%s size=%#x, align=%#x %#x bytes off\n", #type, (int)sizeof(type), (align), (int)RT_ALIGN_Z(sizeof(type), align) - (int)sizeof(type)); \
     156            printf("%s size=%#x (%u), align=%#x %#x (%u) bytes off\n", \
     157                   #type, \
     158                   (unsigned)sizeof(type), \
     159                   (unsigned)sizeof(type), \
     160                   (align), \
     161                   (unsigned)RT_ALIGN_Z(sizeof(type), align) - (unsigned)sizeof(type), \
     162                   (unsigned)RT_ALIGN_Z(sizeof(type), align) - (unsigned)sizeof(type)); \
    152163            rc++; \
    153164        } \
    … …  
    157168 * Checks that a internal struct padding is big enough.
    158169 */
    159 #define CHECK_PADDING(strct, member) \
     170#define CHECK_PADDING(strct, member, align) \
    160171    do \
    161172    { \
    … …  
    164175        { \
    165176            printf("padding of %s::%s is too small, padding=%d struct=%d correct=%d\n", #strct, #member, \
    166                    (int)sizeof(p->member.padding), (int)sizeof(p->member.s), (int)RT_ALIGN_Z(sizeof(p->member.s), 32)); \
     177                   (int)sizeof(p->member.padding), (int)sizeof(p->member.s), (int)RT_ALIGN_Z(sizeof(p->member.s), (align))); \
     178            rc++; \
     179        } \
     180        else if (RT_ALIGN_Z(sizeof(p->member.padding), (align)) != sizeof(p->member.padding)) \
     181        { \
     182            printf("padding of %s::%s is misaligned, padding=%d correct=%d\n", #strct, #member, \
     183                   (int)sizeof(p->member.padding), (int)RT_ALIGN_Z(sizeof(p->member.s), (align))); \
    167184            rc++; \
    168185        } \

  • trunk/src/VBox/Devices/testcase/tstDeviceStructSizeGC.cpp

    r22839 r22885  
    9494#include <stdio.h>
    9595
    96 #define GEN_CHECK_SIZE(s)   printf("    CHECK_SIZE(%s, %d);\n", #s, (int)sizeof(s))
    97 #define GEN_CHECK_OFF(s, m) printf("    CHECK_OFF(%s, %d, %s);\n", #s, (int)RT_OFFSETOF(s, m), #m)
    98 #define GEN_CHECK_PADDING(s, m) printf("    CHECK_PADDING(%s, %s);\n", #s, #m)
     96#define GEN_CHECK_SIZE(s)           printf("    CHECK_SIZE(%s, %d);\n", #s, (int)sizeof(s))
     97#define GEN_CHECK_OFF(s, m)         printf("    CHECK_OFF(%s, %d, %s);\n", #s, (int)RT_OFFSETOF(s, m), #m)
     98#define GEN_CHECK_PADDING(s, m, a)  printf("    CHECK_PADDING(%s, %s, %u);\n", #s, #m, (a))
    9999
    100100int main()
    … …  
    141141    GEN_CHECK_OFF(PCIDEVICE, Int.s.pfnBridgeConfigRead);
    142142    GEN_CHECK_OFF(PCIDEVICE, Int.s.pfnBridgeConfigWrite);
    143     GEN_CHECK_PADDING(PCIDEVICE, Int);
     143    GEN_CHECK_PADDING(PCIDEVICE, Int, 8);
    144144    GEN_CHECK_SIZE(PIIX3State);
    145145    GEN_CHECK_SIZE(PCIBUS);

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

    r22792 r22885  
    18961896    rc = CPUMR3Term(pVM);
    18971897    AssertRC(rc);
     1898    SSMR3Term(pVM);
    18981899    rc = PDMR3CritSectTerm(pVM);
    18991900    AssertRC(rc);

  • trunk/src/VBox/VMM/testcase/tstHelp.h

    r20374 r22885  
    7070    do \
    7171    { \
    72         if ( RT_OFFSETOF(strct, member) & ((align) - 1) ) \
     72        if (RT_OFFSETOF(strct, member) & ((align) - 1) ) \
    7373        { \
    74             printf("%s::%s offset=%#x expected alignment %x, meaning %#x off\n", #strct, #member, (unsigned)RT_OFFSETOF(strct, member), \
    75                    (unsigned)(align), (unsigned)(RT_OFFSETOF(strct, member) & ((align) - 1))); \
     74            printf("%s::%s offset=%#x (%u) expected alignment %x, meaning %#x (%u) off\n", \
     75                   #strct, #member, \
     76                   (unsigned)RT_OFFSETOF(strct, member), \
     77                   (unsigned)RT_OFFSETOF(strct, member), \
     78                   (unsigned)(align), \
     79                   (unsigned)((align) - RT_OFFSETOF(strct, member) & ((align) - 1)), \
     80                   (unsigned)((align) - RT_OFFSETOF(strct, member) & ((align) - 1)) ); \
    7681            rc++; \
    7782        } \
    … …  
    8590        if (RT_ALIGN_Z(sizeof(type), (align)) != sizeof(type)) \
    8691        { \
    87             printf("%s size=%#x, align=%#x %#x bytes off\n", #type, (int)sizeof(type), \
    88                   (align), (int)RT_ALIGN_Z(sizeof(type), align) - (int)sizeof(type)); \
     92            printf("%s size=%#x (%u), align=%#x %#x (%u) bytes off\n", \
     93                   #type, \
     94                   (unsigned)sizeof(type), \
     95                   (unsigned)sizeof(type), \
     96                   (align), \
     97                   (unsigned)RT_ALIGN_Z(sizeof(type), align) - (unsigned)sizeof(type), \
     98                   (unsigned)RT_ALIGN_Z(sizeof(type), align) - (unsigned)sizeof(type)); \
    8999            rc++; \
    90100        } \
    … …  
    94104 * Checks that a internal struct padding is big enough.
    95105 */
    96 #define CHECK_PADDING(strct, member) \
     106#define CHECK_PADDING(strct, member, align) \
    97107    do \
    98108    { \
    … …  
    101111        { \
    102112            printf("padding of %s::%s is too small, padding=%d struct=%d correct=%d\n", #strct, #member, \
    103                    (int)sizeof(p->member.padding), (int)sizeof(p->member.s), (int)RT_ALIGN_Z(sizeof(p->member.s), 64)); \
     113                   (int)sizeof(p->member.padding), (int)sizeof(p->member.s), (int)RT_ALIGN_Z(sizeof(p->member.s), (align))); \
     114            rc++; \
     115        } \
     116        else if (RT_ALIGN_Z(sizeof(p->member.padding), (align)) != sizeof(p->member.padding)) \
     117        { \
     118            printf("padding of %s::%s is misaligned, padding=%d correct=%d\n", #strct, #member, \
     119                   (int)sizeof(p->member.padding), (int)RT_ALIGN_Z(sizeof(p->member.s), (align))); \
    104120            rc++; \
    105121        } \

  • trunk/src/VBox/VMM/testcase/tstVMStructSize.cpp

    r21989 r22885  
    7373    printf("struct VM: %d bytes\n", (int)sizeof(VM));
    7474
    75 #define CHECK_PADDING_VM(member) \
     75#define CHECK_PADDING_VM(align, member) \
    7676    do \
    7777    { \
    78         CHECK_PADDING(VM, member); \
    79         CHECK_MEMBER_ALIGNMENT(VM, member, 32); \
     78        CHECK_PADDING(VM, member, align); \
     79        CHECK_MEMBER_ALIGNMENT(VM, member, align); \
     80        VM *p; \
     81        if (sizeof(p->member.padding) >= (ssize_t)sizeof(p->member.s) + 128 + sizeof(p->member.s) / 20) \
     82            printf("warning: VM::%-8s: padding=%-5d s=%-5d -> %-4d  suggest=%-5u\n", \
     83                   #member, (int)sizeof(p->member.padding), (int)sizeof(p->member.s), \
     84                   (int)sizeof(p->member.padding) - (int)sizeof(p->member.s), \
     85                   (int)RT_ALIGN_Z(sizeof(p->member.s), (align))); \
    8086    } while (0)
    8187
    8288
    83 #define CHECK_PADDING_VMCPU(member) \
     89#define CHECK_PADDING_VMCPU(align, member) \
    8490    do \
    8591    { \
    86         CHECK_PADDING(VMCPU, member); \
    87         CHECK_MEMBER_ALIGNMENT(VMCPU, member, 32); \
     92        CHECK_PADDING(VMCPU, member, align); \
     93        CHECK_MEMBER_ALIGNMENT(VMCPU, member, align); \
     94        VMCPU *p; \
     95        if (sizeof(p->member.padding) >= (ssize_t)sizeof(p->member.s) + 128 + sizeof(p->member.s) / 20) \
     96            printf("warning: VMCPU::%-8s: padding=%-5d s=%-5d -> %-4d  suggest=%-5u\n", \
     97                   #member, (int)sizeof(p->member.padding), (int)sizeof(p->member.s), \
     98                   (int)sizeof(p->member.padding) - (int)sizeof(p->member.s), \
     99                   (int)RT_ALIGN_Z(sizeof(p->member.s), (align))); \
    88100    } while (0)
    89101
    … …  
    137149    CHECK_SIZE(X86PML4, PAGE_SIZE);
    138150
    139     CHECK_PADDING_VM(cfgm);
    140     CHECK_PADDING_VM(cpum);
    141     CHECK_PADDING_VM(dbgf);
    142     CHECK_PADDING_VM(em);
    143     CHECK_PADDING_VM(iom);
    144     CHECK_PADDING_VM(mm);
    145     CHECK_PADDING_VM(pdm);
    146     CHECK_PADDING_VM(pgm);
    147     CHECK_PADDING_VM(selm);
    148     CHECK_PADDING_VM(tm);
    149     CHECK_PADDING_VM(trpm);
    150     CHECK_PADDING_VM(vm);
    151     CHECK_PADDING_VM(vmm);
    152     CHECK_PADDING_VM(ssm);
    153     CHECK_PADDING_VM(rem);
    154     CHECK_PADDING_VM(hwaccm);
    155     CHECK_PADDING_VM(patm);
    156     CHECK_PADDING_VM(csam);
    157 
    158     CHECK_PADDING_VMCPU(cpum);
    159     CHECK_PADDING_VMCPU(pgm);
    160     CHECK_PADDING_VMCPU(em);
    161     CHECK_PADDING_VMCPU(hwaccm);
    162     CHECK_PADDING_VMCPU(trpm);
    163     CHECK_PADDING_VMCPU(tm);
    164     CHECK_PADDING_VMCPU(vmm);
     151    CHECK_PADDING_VM(64, cpum);
     152    CHECK_PADDING_VM(64, vmm);
     153    CHECK_PADDING_VM(64, pgm);
     154    CHECK_PADDING_VM(64, hwaccm);
     155    CHECK_PADDING_VM(64, trpm);
     156    CHECK_PADDING_VM(64, selm);
     157    CHECK_PADDING_VM(64, mm);
     158    CHECK_PADDING_VM(64, pdm);
     159    CHECK_PADDING_VM(64, iom);
     160    CHECK_PADDING_VM(64, patm);
     161    CHECK_PADDING_VM(64, csam);
     162    CHECK_PADDING_VM(64, em);
     163    CHECK_PADDING_VM(64, tm);
     164    CHECK_PADDING_VM(64, dbgf);
     165    CHECK_PADDING_VM(64, ssm);
     166    CHECK_PADDING_VM(64, rem);
     167    CHECK_PADDING_VM(8, vm);
     168#ifdef VBOX_WITH_VMI
     169    CHECK_PADDING_VM(8, parav);
     170#endif
     171    CHECK_PADDING_VM(8, cfgm);
     172
     173    CHECK_PADDING_VMCPU(64, cpum);
     174    CHECK_PADDING_VMCPU(64, pgm);
     175    CHECK_PADDING_VMCPU(64, hwaccm);
     176    CHECK_PADDING_VMCPU(64, em);
     177    CHECK_PADDING_VMCPU(64, trpm);
     178    CHECK_PADDING_VMCPU(64, tm);
     179    CHECK_PADDING_VMCPU(64, vmm);
     180    CHECK_PADDING_VMCPU(64, pdm);
     181    CHECK_PADDING_VMCPU(64, iom);
     182    CHECK_PADDING_VMCPU(64, dbgf);
    165183
    166184    CHECK_MEMBER_ALIGNMENT(VM, selm.s.Tss, 16);
    … …  
    207225    CHECK_MEMBER_ALIGNMENT(VM, rem.s.StatsInQEMU, 8);
    208226    CHECK_MEMBER_ALIGNMENT(VM, rem.s.Env, 32);
    209     CHECK_MEMBER_ALIGNMENT(VM, aCpus, 64);
    210 
    211     /* vmcpu */
    212     CHECK_MEMBER_ALIGNMENT(VMCPU, cpum, 64);
    213     CHECK_MEMBER_ALIGNMENT(VMCPU, vmm, 32);
    214     CHECK_MEMBER_ALIGNMENT(VMCPU, pgm, 32);
    215     CHECK_MEMBER_ALIGNMENT(VMCPU, em, 32);
    216     CHECK_MEMBER_ALIGNMENT(VMCPU, hwaccm, 32);
    217     CHECK_MEMBER_ALIGNMENT(VMCPU, tm, 32);
    218     CHECK_SIZE_ALIGNMENT(VMCPU, 32);
     227
     228    /* the VMCPUs are page aligned TLB hit reassons. */
     229    CHECK_MEMBER_ALIGNMENT(VM, aCpus, 4096);
     230    CHECK_SIZE_ALIGNMENT(VMCPU, 4096);
    219231
    220232    /* cpumctx */
    … …  
    268280    /* pdm */
    269281    CHECK_MEMBER_ALIGNMENT(PDMDEVINS, achInstanceData, 64);
    270     CHECK_PADDING(PDMDEVINS, Internal);
     282    CHECK_PADDING(PDMDEVINS, Internal, 1);
    271283    CHECK_MEMBER_ALIGNMENT(PDMUSBINS, achInstanceData, 16);
    272     CHECK_PADDING(PDMUSBINS, Internal);
     284    CHECK_PADDING(PDMUSBINS, Internal, 1);
    273285    CHECK_MEMBER_ALIGNMENT(PDMDRVINS, achInstanceData, 16);
    274     CHECK_PADDING(PDMDRVINS, Internal);
     286    CHECK_PADDING(PDMDRVINS, Internal, 1);
    275287    CHECK_PADDING2(PDMCRITSECT);
    276288    CHECK_MEMBER_ALIGNMENT(PGMPOOLPAGE, idx, sizeof(uint16_t));
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