Changeset 54252 in vbox

Timestamp:

Feb 17, 2015 7:24:45 PM (10 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

98319

Message:

SUPDrv,GIP,TM: Combined fOsTscDeltasInSync and fTscDeltasRoughlyInSync into enmUseTscDelta and added fGetGipCpu. Bumped GIP and support driver versions.

Location:

trunk

Files:

• include/VBox/sup.h (modified) (5 diffs)
• include/VBox/sup.mac (modified) (4 diffs)
• src/VBox/HostDrivers/Support/SUPDrv.c (modified) (39 diffs)
• src/VBox/HostDrivers/Support/SUPDrvIOC.h (modified) (4 diffs)
• src/VBox/HostDrivers/Support/testcase/tstGIP-2.cpp (modified) (1 diff)
• src/VBox/Runtime/common/time/timesup.cpp (modified) (1 diff)
• src/VBox/Runtime/testcase/tstRTTime.cpp (modified) (1 diff)
• src/VBox/VMM/VMMR3/TM.cpp (modified) (10 diffs)

trunk/include/VBox/sup.h ¶

@@ -284 +284 @@
 
 
+/**
+ * The rules concerning the applicability of SUPGIPCPU::i64TscDelta.
+ */
+typedef enum SUPGIPUSETSCDELTA
+{
+    /** Value for SUPGIPMODE_ASYNC_TSC. */
+    SUPGIPUSETSCDELTA_NOT_APPLICABLE = 0,
+    /** The OS specific part of SUPDrv (or the user) claims the TSC is as
+     * good as zero. */
+    SUPGIPUSETSCDELTA_ZERO_CLAIMED,
+    /** The differences in RDTSC output between the CPUs/cores/threads should
+     * be considered zero for all practical purposes. */
+    SUPGIPUSETSCDELTA_PRACTICALLY_ZERO,
+    /** The differences in RDTSC output between the CPUs/cores/threads are a few
+     * hundred ticks or less.  (Probably not worth calling ASMGetApicId two times
+     * just to apply deltas.) */
+    SUPGIPUSETSCDELTA_ROUGHLY_ZERO,
+    /** Significant differences in RDTSC output between the CPUs/cores/threads,
+     * deltas must be applied. */
+    SUPGIPUSETSCDELTA_NOT_ZERO,
+    /** End of valid values (exclusive). */
+    SUPGIPUSETSCDELTA_END,
+    /** Make sure the type is 32-bit sized. */
+    SUPGIPUSETSCDELTA_32BIT_HACK = 0x7fffffff
+} SUPGIPUSETSCDELTA;
+
+
+/** @name SUPGIPGETCPU_XXX - methods that aCPUs can be indexed.
+ * @{
+ */
+/** Use ASMGetApicId (or equivalent) and translate the result via
+ *  aiCpuFromApicId. */
+#define SUPGIPGETCPU_APIC_ID                        RT_BIT_32(0)
+/** Use RDTSCP and translate the first RTCPUSET_MAX_CPUS of ECX via
+ * aiCpuFromCpuSetIdx.
+ *
+ * Linux stores the RTMpCpuId() value in ECX[11:0] and NUMA node number in
+ * ECX[12:31].  Solaris only stores RTMpCpuId() in ECX.  On both systems
+ * RTMpCpuId() == RTMpCpuIdToSetIndex(RTMpCpuId()).  RTCPUSET_MAX_CPUS is
+ * currently 64, 256 or 1024 in size, which lower than
+ * 4096, so there shouldn't be any range issues. */
+#define SUPGIPGETCPU_RDTSCP_MASK_MAX_SET_CPUS       RT_BIT_32(1)
+/** Subtract the max IDT size from IDTR.LIMIT, extract the
+ * first RTCPUSET_MAX_CPUS and translate it via aiCpuFromCpuSetIdx.
+ *
+ * Darwin stores the RTMpCpuId() (== RTMpCpuIdToSetIndex(RTMpCpuId()))
+ * value in the IDT limit.  The masking is a precaution against what linux
+ * does with RDTSCP. */
+#define SUPGIPGETCPU_IDTR_LIMIT_MASK_MAX_SET_CPUS   RT_BIT_32(2)
+/* Linux also offers information via selector 0x78, but we'll settle for
+   RDTSCP for now. */
+/** @} */
+
 
 /**
@@ -329 +382 @@
     /** The max CPU ID (RTMpGetMaxCpuId). */
     RTCPUID             idCpuMax;
-    /** Whether the host OS has already normalized the hardware TSC deltas across
-     *  CPUs. */
-    bool                fOsTscDeltasInSync;
-    /** Whether the TSC deltas are small enough to not bother applying. */
-    bool                fTscDeltasRoughlyInSync;
-    uint8_t             au8Padding0[2];
+    /** The applicability of SUPGIPCPU::i64TscDelta. */
+    SUPGIPUSETSCDELTA   enmUseTscDelta;
+    /** Mask of SUPGIPGETCPU_XXX values that indicates different ways that aCPU
+     * can be accessed from ring-3 and raw-mode context. */
+    uint32_t            fGetGipCpu;
 
     /** Padding / reserved space for future data. */
-    uint32_t            au32Padding1[26];
+    uint32_t            au32Padding1[25];
 
     /** Table indexed by the CPU APIC ID to get the CPU table index. */
@@ -370 +422 @@
  * Upper 16 bits is the major version. Major version is only changed with
  * incompatible changes in the GIP. */
-#define SUPGLOBALINFOPAGE_VERSION   0x00050000
+#define SUPGLOBALINFOPAGE_VERSION   0x00060000
 
 /**
@@ -436 +488 @@
 
 /** Whether the application of TSC-deltas is required. */
-#define GIP_ARE_TSC_DELTAS_APPLICABLE(a_pGip) \
-    ((a_pGip)->u32Mode == SUPGIPMODE_INVARIANT_TSC && !((a_pGip)->fOsTscDeltasInSync))
+#define GIP_ARE_TSC_DELTAS_APPLICABLE(a_pGip)  ((a_pGip)->enmUseTscDelta > SUPGIPUSETSCDELTA_PRACTICALLY_ZERO)
 
 
@@ -1559 +1610 @@
 DECLINLINE(uint64_t) SUPReadTsc(void)
 {
-    if (    GIP_ARE_TSC_DELTAS_APPLICABLE(g_pSUPGlobalInfoPage)
-        && !g_pSUPGlobalInfoPage->fTscDeltasRoughlyInSync)
+    if (g_pSUPGlobalInfoPage->enmUseTscDelta > SUPGIPUSETSCDELTA_ROUGHLY_ZERO)
         return SUPReadTscWithDelta();
     return ASMReadTSC();

trunk/include/VBox/sup.mac ¶

@@ -5 +5 @@
 
 ;
-; Copyright (C) 2006-2014 Oracle Corporation
+; Copyright (C) 2006-2015 Oracle Corporation
 ;
 ; This file is part of VirtualBox Open Source Edition (OSE), as
@@ -48 +48 @@
 endstruc
 
+%define SUPGIPUSETSCDELTA_NOT_APPLICABLE        0
+%define SUPGIPUSETSCDELTA_ZERO_CLAIMED          1
+%define SUPGIPUSETSCDELTA_PRACTICALLY_ZERO      2
+%define SUPGIPUSETSCDELTA_ROUGHLY_ZERO          3
+%define SUPGIPUSETSCDELTA_NOT_ZERO              4
+
+%define SUPGIPGETCPU_APIC_ID                        1
+%define SUPGIPGETCPU_RDTSCP_MASK_MAX_SET_CPUS       2
+%define SUPGIPGETCPU_IDTR_LIMIT_MASK_MAX_SET_CPUS   4
+
+
 %define SUPGLOBALINFOPAGE_MAGIC 0x19590106
 struc SUPGLOBALINFOPAGE
@@ -67 +78 @@
     .u16Padding0                resw 1
     .idCpuMax                   resd 1
-    .fOsTscDeltasInSync         resb 1
-    .fTscDeltasRoughlyInSync    resb 1
-    .au8Padding0                resb 2
-    .au32Padding1               resd 26
+    .enmUseTscDelta             resd 1
+    .fGetGipCpu                 resd 1
+    .au32Padding1               resd 25
     .aiCpuFromApicId            resw 256
     .aiCpuFromCpuSetIdx         resw 256
@@ -126 +136 @@
 endstruc
 
-;;
-; Macro to apply per-CPU TSC delta to the TSC value read in through rdtsc.
-;
-; @param   %1    The pSupGipCpu pointer
-; @remarks edx:eax contains the 64-bit TSC value to apply the delta to.
-%macro SUPTscDeltaApply 1
-    ; Check if we have a valid TSC-delta, i.e. != INT64_MAX.
-    cmp     dword [%1 + SUPGIPCPU.i64TSCDelta], 0xffffffff
-    jne     %%valid_delta
-    cmp     dword [%1 + SUPGIPCPU.i64TSCDelta + 4], 0x7fffffff
-    je      %%done
-%%valid_delta:
-    ; Subtract the delta from edx:eax
-    sub     eax, dword [%1 + SUPGIPCPU.i64TSCDelta]
-    sbb     edx, dword [%1 + SUPGIPCPU.i64TSCDelta + 4]
-%%done:
-%endmacro
-
 %endif
 

trunk/src/VBox/HostDrivers/Support/SUPDrv.c ¶

@@ -124 +124 @@
 /** The TSC-refinement interval in seconds. */
 #define GIP_TSC_REFINE_INTERVAL             5
-/** The TSC-delta threshold (in ticks) for whether it's worth applying them or
- *  not for performance reasons, see @bugref{6710} comment #124. */
-#define GIP_TSC_DELTA_APPLY_THRESHOLD       384
+/** The TSC-delta threshold for the SUPGIPUSETSCDELTA_PRACTICALLY_ZERO rating */
+#define GIP_TSC_DELTA_THRESHOLD_PRACTICALLY_ZERO    24
+/** The TSC-delta threshold for the SUPGIPUSETSCDELTA_ROUGHLY_ZERO rating */
+#define GIP_TSC_DELTA_THRESHOLD_ROUGHLY_ZERO        384
 
 AssertCompile(GIP_TSC_DELTA_PRIMER_LOOPS < GIP_TSC_DELTA_READ_TIME_LOOPS);
@@ -163 +164 @@
 static int                  supdrvIOCtl_LoggerSettings(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLOGGERSETTINGS pReq);
 static int                  supdrvIOCtl_MsrProber(PSUPDRVDEVEXT pDevExt, PSUPMSRPROBER pReq);
-static int                  supdrvIOCtl_TscDeltaMeasure(PSUPDRVDEVEXT pDevExt, PSUPTSCDELTAMEASURE pReq);
+static int                  supdrvIOCtl_TscDeltaMeasure(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPTSCDELTAMEASURE pReq);
 static int                  supdrvIOCtl_TscRead(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPTSCREAD pReq);
 static int                  supdrvGipCreate(PSUPDRVDEVEXT pDevExt);
 static void                 supdrvGipDestroy(PSUPDRVDEVEXT pDevExt);
-static DECLCALLBACK(void)   supdrvGipSyncTimer(PRTTIMER pTimer, void *pvUser, uint64_t iTick);
+static DECLCALLBACK(void)   supdrvGipSyncAndInvariantTimer(PRTTIMER pTimer, void *pvUser, uint64_t iTick);
 static DECLCALLBACK(void)   supdrvGipAsyncTimer(PRTTIMER pTimer, void *pvUser, uint64_t iTick);
 static DECLCALLBACK(void)   supdrvGipMpEvent(RTMPEVENT enmEvent, RTCPUID idCpu, void *pvUser);
@@ -2252 +2253 @@
             REQ_CHECK_SIZES(SUP_IOCTL_TSC_DELTA_MEASURE);
 
-            pReqHdr->rc = supdrvIOCtl_TscDeltaMeasure(pDevExt, pReq);
+            pReqHdr->rc = supdrvIOCtl_TscDeltaMeasure(pDevExt, pSession, pReq);
             return 0;
         }
@@ -4031 +4032 @@
 
 /**
+ * State structure for supdrvGipDetectGetGipCpuCallback.
+ */
+typedef struct SUPDRVGIPDETECTGETCPU
+{
+    /** Bitmap of APIC IDs that has been seen (initialized to zero).
+     *  Used to detect duplicate APIC IDs (paranoia). */
+    uint8_t volatile    bmApicId[256 / 8];
+    /** Mask of supported GIP CPU getter methods (SUPGIPGETCPU_XXX) (all bits set
+     *  initially). The callback clears the methods not detected. */
+    uint32_t volatile   fSupported;
+    /** The first callback detecting any kind of range issues (initializsed to
+     * NIL_RTCPUID). */
+    RTCPUID volatile    idCpuProblem;
+} SUPDRVGIPDETECTGETCPU;
+/** Pointer to state structure for supdrvGipDetectGetGipCpuCallback. */
+typedef SUPDRVGIPDETECTGETCPU *PSUPDRVGIPDETECTGETCPU;
+
+
+/**
+ * Checks for alternative ways of getting the CPU ID.
+ *
+ * This also checks the APIC ID, CPU ID and CPU set index values against the
+ * GIP tables.
+ *
+ * @param   idCpu            The CPU ID. Unused - we have to use the APIC ID.
+ * @param   pvUser1          Pointer to the state structure.
+ * @param   pvUser2          Pointer to the GIP.
+ */
+static DECLCALLBACK(void) supdrvGipDetectGetGipCpuCallback(RTCPUID idCpu, void *pvUser1, void *pvUser2)
+{
+    PSUPDRVGIPDETECTGETCPU  pState = (PSUPDRVGIPDETECTGETCPU)pvUser1;
+    PSUPGLOBALINFOPAGE      pGip   = (PSUPGLOBALINFOPAGE)pvUser2;
+    uint32_t                fSupported = 0;
+    uint16_t                idApic;
+    int                     iCpuSet;
+
+    AssertMsg(idCpu == RTMpCpuId(), ("idCpu=%#x RTMpCpuId()=%#x\n", idCpu, RTMpCpuId())); /* paranoia^3 */
+
+    /*
+     * Check that the CPU ID and CPU set index are interchangable.
+     */
+    iCpuSet = RTMpCpuIdToSetIndex(idCpu);
+    if ((RTCPUID)iCpuSet == idCpu)
+    {
+        AssertCompile(RT_IS_POWER_OF_TWO(RTCPUSET_MAX_CPUS));
+        if (   iCpuSet >= 0
+            && iCpuSet < RTCPUSET_MAX_CPUS
+            && RT_IS_POWER_OF_TWO(RTCPUSET_MAX_CPUS))
+        {
+            /*
+             * Check whether the IDTR.LIMIT contains a CPU number.
+             */
+#ifdef RT_ARCH_X86
+            uint16_t const  cbIdt = sizeof(X86DESC64SYSTEM);
+#else
+            uint16_t const  cbIdt = sizeof(X86DESCGATE);
+#endif
+            RTIDTR          Idtr;
+            ASMGetIDTR(&Idtr);
+            if (Idtr.cbIdt >= cbIdt)
+            {
+                uint32_t uTmp = Idtr.cbIdt - cbIdt;
+                uTmp &= RTCPUSET_MAX_CPUS - 1;
+                if (uTmp == idCpu)
+                {
+                    RTIDTR Idtr2;
+                    ASMGetIDTR(&Idtr2);
+                    if (Idtr2.cbIdt == Idtr.cbIdt)
+                        fSupported |= SUPGIPGETCPU_IDTR_LIMIT_MASK_MAX_SET_CPUS;
+                }
+            }
+
+            /*
+             * Check whether RDTSCP is an option.
+             */
+            if (ASMHasCpuId())
+            {
+                if (   ASMIsValidExtRange(ASMCpuId_EAX(UINT32_C(0x80000000)))
+                    && (ASMCpuId_EDX(UINT32_C(0x80000001)) & X86_CPUID_EXT_FEATURE_EDX_RDTSCP) )
+                {
+                    uint32_t uAux;
+                    ASMReadTscWithAux(&uAux);
+                    if ((uAux & (RTCPUSET_MAX_CPUS - 1)) == idCpu)
+                    {
+                        ASMNopPause();
+                        ASMReadTscWithAux(&uAux);
+                        if ((uAux & (RTCPUSET_MAX_CPUS - 1)) == idCpu)
+                            fSupported |= SUPGIPGETCPU_RDTSCP_MASK_MAX_SET_CPUS;
+                    }
+                }
+            }
+        }
+    }
+
+    /*
+     * Check that the APIC ID is unique.
+     */
+    idApic = ASMGetApicId();
+    if (RT_LIKELY(   idApic < RT_ELEMENTS(pGip->aiCpuFromApicId)
+                  && !ASMAtomicBitTestAndSet(pState->bmApicId, idApic)))
+        fSupported |= SUPGIPGETCPU_APIC_ID;
+    else
+    {
+        AssertCompile(sizeof(pState->bmApicId) * 8 == RT_ELEMENTS(pGip->aiCpuFromApicId));
+        ASMAtomicCmpXchgU32(&pState->idCpuProblem, idCpu, NIL_RTCPUID);
+        LogRel(("supdrvGipDetectGetGipCpuCallback: idCpu=%#x iCpuSet=%d idApic=%#x - duplicate APIC ID.\n", 
+                idCpu, iCpuSet, idApic));
+    }
+
+    /*
+     * Check that the iCpuSet is within the expected range.
+     */
+    if (RT_UNLIKELY(   iCpuSet < 0
+                    || iCpuSet >= RTCPUSET_MAX_CPUS
+                    || iCpuSet >= RT_ELEMENTS(pGip->aiCpuFromCpuSetIdx)))
+    {
+        ASMAtomicCmpXchgU32(&pState->idCpuProblem, idCpu, NIL_RTCPUID);
+        LogRel(("supdrvGipDetectGetGipCpuCallback: idCpu=%#x iCpuSet=%d idApic=%#x - CPU set index is out of range.\n", 
+                idCpu, iCpuSet, idApic));
+    }
+    else
+    {
+        RTCPUID idCpu2 = RTMpCpuIdFromSetIndex(iCpuSet);
+        if (RT_UNLIKELY(idCpu2 != idCpu))
+        {
+            ASMAtomicCmpXchgU32(&pState->idCpuProblem, idCpu, NIL_RTCPUID);
+            LogRel(("supdrvGipDetectGetGipCpuCallback: idCpu=%#x iCpuSet=%d idApic=%#x - CPU id/index roundtrip problem: %#x\n",
+                    idCpu, iCpuSet, idApic, idCpu2));
+        }
+    }
+
+    /*
+     * Update the supported feature mask before we return.
+     */
+    ASMAtomicAndU32(&pState->fSupported, fSupported);
+
+    NOREF(pvUser2);
+}
+
+
+/**
  * Increase the timer freqency on hosts where this is possible (NT).
  *
@@ -4138 +4280 @@
                 uint64_t u64NanoTS;
 
+                /*
+                 * GIP starts/resumes updating again.  On windows we bump the
+                 * host timer frequency to make sure we don't get stuck in guest
+                 * mode and to get better timer (and possibly clock) accuracy.
+                 */
                 LogFlow(("SUPR0GipMap: Resumes GIP updating\n"));
 
                 supdrvGipRequestHigherTimerFrequencyFromSystem(pDevExt);
 
+                /*
+                 * document me
+                 */
                 if (pGipR0->aCPUs[0].u32TransactionId != 2 /* not the first time */)
                 {
@@ -4152 +4302 @@
                 }
 
+                /*
+                 * document me
+                 */
                 u64NanoTS = RTTimeSystemNanoTS() - pGipR0->u32UpdateIntervalNS;
                 if (   pGipR0->u32Mode == SUPGIPMODE_INVARIANT_TSC
@@ -4160 +4313 @@
                     RTMpOnAll(supdrvGipReInitCpuCallback, pGipR0, &u64NanoTS);
 
+                /*
+                 * Detect alternative ways to figure the CPU ID in ring-3 and
+                 * raw-mode context.  Check the sanity of the APIC IDs, CPU IDs,
+                 * and CPU set indexes while we're at it.
+                 */
+                if (RT_SUCCESS(rc))
+                {
+                    SUPDRVGIPDETECTGETCPU DetectState;
+                    RT_ZERO(DetectState.bmApicId);
+                    DetectState.fSupported   = UINT32_MAX;
+                    DetectState.idCpuProblem = NIL_RTCPUID;
+                    rc = RTMpOnAll(supdrvGipDetectGetGipCpuCallback, &DetectState, pGipR0);
+                    if (DetectState.idCpuProblem == NIL_RTCPUID)
+                    {
+                        if (   DetectState.fSupported != UINT32_MAX
+                            && DetectState.fSupported != 0)
+                        {
+                            if (pGipR0->fGetGipCpu != DetectState.fSupported)
+                            {
+                                pGipR0->fGetGipCpu = DetectState.fSupported;
+                                LogRel(("SUPR0GipMap: fGetGipCpu=%#x\n", DetectState.fSupported));
+                            }
+                        }
+                        else
+                        {
+                            LogRel(("SUPR0GipMap: No supported ways of getting the APIC ID or CPU number in ring-3! (%#x)\n",
+                                    DetectState.fSupported));
+                            rc = VERR_UNSUPPORTED_CPU;
+                        }
+                    }
+                    else
+                    {
+                        LogRel(("SUPR0GipMap: APIC ID, CPU ID or CPU set index problem detected on CPU #%u (%#x)!\n",
+                                DetectState.idCpuProblem, DetectState.idCpuProblem));
+                        rc = VERR_INVALID_CPU_ID;
+                    }
+                }
+
+                /*
+                 * Start the GIP timer if all is well..
+                 */
+                if (RT_SUCCESS(rc))
+                {
 #ifndef DO_NOT_START_GIP
-                rc = RTTimerStart(pDevExt->pGipTimer, 0 /* fire ASAP */); AssertRC(rc);
+                    rc = RTTimerStart(pDevExt->pGipTimer, 0 /* fire ASAP */); AssertRC(rc);
 #endif
-                rc = VINF_SUCCESS;
+                    rc = VINF_SUCCESS;
+                }
+
+                /*
+                 * Bail out on error.
+                 */
+                if (RT_FAILURE(rc))
+                {
+                    LogRel(("SUPR0GipMap: failed rc=%Rrc\n", rc));
+                    pDevExt->cGipUsers = 0;
+                    pSession->fGipReferenced = 0;
+                    if (pSession->GipMapObjR3 != NIL_RTR0MEMOBJ)
+                    {
+                        int rc2 = RTR0MemObjFree(pSession->GipMapObjR3, false); AssertRC(rc2);
+                        if (RT_SUCCESS(rc2))
+                            pSession->GipMapObjR3 = NIL_RTR0MEMOBJ;
+                    }
+                    HCPhys = NIL_RTHCPHYS;
+                    pGipR3 = NIL_RTR3PTR;
+                }
             }
         }
@@ -5781 +5996 @@
 }
 
-
 #ifdef SUPDRV_USE_TSC_DELTA_THREAD
+
 /**
  * Switches the TSC-delta measurement thread into the butchered state.
@@ -6035 +6250 @@
 static int supdrvTscDeltaThreadInit(PSUPDRVDEVEXT pDevExt)
 {
-    Assert(GIP_ARE_TSC_DELTAS_APPLICABLE(pDevExt->pGip));
+    Assert(pDevExt->pGip->enmUseTscDelta > SUPGIPUSETSCDELTA_ZERO_CLAIMED);
 
     int rc = RTSpinlockCreate(&pDevExt->hTscDeltaSpinlock, RTSPINLOCK_FLAGS_INTERRUPT_UNSAFE, "VBoxTscSpnLck");
@@ -6136 +6351 @@
     return VERR_TIMEOUT;
 }
+
 #endif /* SUPDRV_USE_TSC_DELTA_THREAD */
-
 
 /**
@@ -6164 +6379 @@
     AssertPtr(puTsc);
     AssertPtr(pGip);
-    Assert(GIP_ARE_TSC_DELTAS_APPLICABLE(pGip));
+    Assert(pGip->enmUseTscDelta > SUPGIPUSETSCDELTA_ZERO_CLAIMED);
 
     /*
@@ -6284 +6499 @@
         ASMSetFlags(uFlags);
 
-        if (GIP_ARE_TSC_DELTAS_APPLICABLE(pGip))
+        if (pGip->enmUseTscDelta > SUPGIPUSETSCDELTA_PRACTICALLY_ZERO)
         {
             int rc;
@@ -6362 +6577 @@
     u64NanoTS = RTTimeSystemNanoTS();
     ASMSetFlags(uFlags);
-    if (GIP_ARE_TSC_DELTAS_APPLICABLE(pGip))
+    if (pGip->enmUseTscDelta > SUPGIPUSETSCDELTA_PRACTICALLY_ZERO)
         supdrvTscDeltaApply(pGip, &u64Tsc, idApic, &fDeltaApplied);
     u64DeltaNanoTS = u64NanoTS - pDevExt->u64NanoTSAnchor;
@@ -6381 +6596 @@
     else
     {
-#if 1
         RTUINT128U CpuHz, Tmp, Divisor;
         CpuHz.s.Lo = CpuHz.s.Hi = 0;
@@ -6387 +6601 @@
         RTUInt128Div(&CpuHz, &Tmp, RTUInt128AssignU64(&Divisor, u64DeltaNanoTS));
         pGip->u64CpuHz = CpuHz.s.Lo;
-#else
-        /** @todo remove later */
-        /* Try not to lose precision, the larger the interval the more likely we overflow. */
-        if (   u64DeltaTsc < UINT64_MAX / RT_NS_100MS
-            && u64DeltaNanoTS / 10 < UINT32_MAX)
-            pGip->u64CpuHz = ASMMultU64ByU32DivByU32(u64DeltaTsc, RT_NS_100MS, (uint32_t)(u64DeltaNanoTS / 10));
-        else if (   u64DeltaTsc < UINT64_MAX / RT_NS_10MS
-                 && u64DeltaNanoTS / 100 < UINT32_MAX)
-            pGip->u64CpuHz = ASMMultU64ByU32DivByU32(u64DeltaTsc, RT_NS_10MS, (uint32_t)(u64DeltaNanoTS / 100));
-        else if (   u64DeltaTsc < UINT64_MAX / RT_NS_1MS
-                 && u64DeltaNanoTS / 1000 < UINT32_MAX)
-            pGip->u64CpuHz = ASMMultU64ByU32DivByU32(u64DeltaTsc, RT_NS_1MS, (uint32_t)(u64DeltaNanoTS / 1000));
-        else /* Screw it. */
-            pGip->u64CpuHz = u64DeltaTsc / (u64DeltaNanoTS / RT_NS_1SEC_64);
-#endif
     }
 
@@ -6428 +6627 @@
     Assert(pDevExt->pGip);
 
+    /*
+     * <Insert missing comment [it's not "Validate.", I think...]>
+     */ 
     pGip = pDevExt->pGip;
     u64NanoTS = RTTimeSystemNanoTS();
@@ -6437 +6639 @@
     pDevExt->u64NanoTSAnchor = RTTimeSystemNanoTS();
     ASMSetFlags(uFlags);
-    if (GIP_ARE_TSC_DELTAS_APPLICABLE(pGip))
+    if (pGip->enmUseTscDelta > SUPGIPUSETSCDELTA_PRACTICALLY_ZERO)
         supdrvTscDeltaApply(pGip, &pDevExt->u64TscAnchor, idApic, &fDeltaApplied);
 
 #ifdef SUPDRV_USE_TSC_DELTA_THREAD
+    /* 
+     * <Explain yourself>
+     */
+    /** @todo r=bird: This is (and was) bogus on systems where we don't need to
+     *        apply any delta (not used on windows doesn't stick without comments).
+     *        What is the logic you want here exactly? */
     if (   pGip->u32Mode == SUPGIPMODE_INVARIANT_TSC
         && !fDeltaApplied)
@@ -6541 +6749 @@
     supdrvGipInit(pDevExt, pGip, HCPhysGip, RTTimeSystemNanoTS(), RT_NS_1SEC / u32Interval /*=Hz*/, u32Interval, cCpus);
 
-    if (RT_UNLIKELY(   pGip->fOsTscDeltasInSync
+    if (RT_UNLIKELY(   pGip->enmUseTscDelta == SUPGIPUSETSCDELTA_ZERO_CLAIMED
                     && pGip->u32Mode == SUPGIPMODE_ASYNC_TSC
                     && !supdrvOSGetForcedAsyncTscMode(pDevExt)))
@@ -6551 +6759 @@
 
 #ifdef SUPDRV_USE_TSC_DELTA_THREAD
-    if (GIP_ARE_TSC_DELTAS_APPLICABLE(pGip))
+    if (pGip->enmUseTscDelta > SUPGIPUSETSCDELTA_ZERO_CLAIMED)
     {
         /* Initialize TSC-delta measurement thread before executing any Mp event callbacks. */
@@ -6567 +6775 @@
                 uint16_t iCpu;
 #ifndef SUPDRV_USE_TSC_DELTA_THREAD
-                if (GIP_ARE_TSC_DELTAS_APPLICABLE(pGip))
+                if (pGip->enmUseTscDelta > SUPGIPUSETSCDELTA_ZERO_CLAIMED)
                 {
                     /*
@@ -6608 +6816 @@
                         }
                         if (pGip->u32Mode != SUPGIPMODE_ASYNC_TSC)
-                            rc = RTTimerCreateEx(&pDevExt->pGipTimer, u32Interval, 0 /* fFlags */, supdrvGipSyncTimer, pDevExt);
+                            rc = RTTimerCreateEx(&pDevExt->pGipTimer, u32Interval, 0 /* fFlags */, 
+                                                 supdrvGipSyncAndInvariantTimer, pDevExt);
                         if (RT_SUCCESS(rc))
                         {
@@ -6722 +6931 @@
 
 /**
- * Timer callback function sync GIP mode.
+ * Timer callback function for the sync and invariant  GIP modes. 
+ *  
  * @param   pTimer      The timer.
  * @param   pvUser      Opaque pointer to the device extension.
  * @param   iTick       The timer tick.
  */
-static DECLCALLBACK(void) supdrvGipSyncTimer(PRTTIMER pTimer, void *pvUser, uint64_t iTick)
+static DECLCALLBACK(void) supdrvGipSyncAndInvariantTimer(PRTTIMER pTimer, void *pvUser, uint64_t iTick)
 {
     RTCCUINTREG        uFlags;
@@ -6739 +6949 @@
     u64NanoTS = RTTimeSystemNanoTS();
 
-    if (GIP_ARE_TSC_DELTAS_APPLICABLE(pGip))
+    if (pGip->enmUseTscDelta > SUPGIPUSETSCDELTA_PRACTICALLY_ZERO)
     {
         /*
@@ -6747 +6957 @@
          * rescheduling the tick to be delivered on the right CPU or missing the tick entirely.
          *
-         * The likely hood of this happening is really low. On Windows, Linux timers
-         * fire on the CPU they were registered/started on. Darwin, Solaris need verification.
+         * The likely hood of this happening is really low. On Windows, Linux, and Solaris
+         * timers fire on the CPU they were registered/started on.  Darwin timers doesn't
+         * necessarily (they are high priority threads waiting).
          */
         Assert(!ASMIntAreEnabled());
@@ -6884 +7095 @@
      * update the state and it'll get serviced when the thread's listening interval times out.
      */
-    if (GIP_ARE_TSC_DELTAS_APPLICABLE(pGip))
+    if (pGip->enmUseTscDelta > SUPGIPUSETSCDELTA_ZERO_CLAIMED)
     {
         RTSpinlockAcquire(pDevExt->hTscDeltaSpinlock);
@@ -6943 +7154 @@
 
     /* Reset the TSC delta, we will recalculate it lazily. */
-    if (GIP_ARE_TSC_DELTAS_APPLICABLE(pGip))
+    if (pGip->enmUseTscDelta > SUPGIPUSETSCDELTA_ZERO_CLAIMED)
         ASMAtomicWriteS64(&pGip->aCPUs[i].i64TSCDelta, INT64_MAX);
 
@@ -7172 +7383 @@
 
                 while (ASMAtomicReadU32(&pDevExt->pTscDeltaSync->u) == GIP_TSC_DELTA_SYNC_START)
-                    ;
+                { /* nothing */ }
 
                 do
@@ -7183 +7394 @@
 
                 while (ASMAtomicReadU32(&pDevExt->pTscDeltaSync->u) != GIP_TSC_DELTA_SYNC_WORKER_DONE)
-                    ;
+                { /* nothing */ }
 
                 if (i > GIP_TSC_DELTA_PRIMER_LOOPS + GIP_TSC_DELTA_READ_TIME_LOOPS)
@@ -7209 +7420 @@
                 ASMAtomicReadU64(&pGipCpuMaster->u64TSCSample);     /* Warm the cache line. */
                 while (ASMAtomicReadU32(&pDevExt->pTscDeltaSync->u) != GIP_TSC_DELTA_SYNC_START)
-                    ;
+                { /* nothing */ }
                 Assert(pGipCpuMaster->u64TSCSample == GIP_TSC_DELTA_RSVD);
                 ASMAtomicWriteU32(&pDevExt->pTscDeltaSync->u, GIP_TSC_DELTA_SYNC_WORKER_READY);
@@ -7307 +7518 @@
     pGipCpuWorker = &pGip->aCPUs[idxWorker];
 
-    Assert(GIP_ARE_TSC_DELTAS_APPLICABLE(pGip));
+    Assert(pGip->enmUseTscDelta > SUPGIPUSETSCDELTA_ZERO_CLAIMED);
 
     if (pGipCpuWorker->idCpu == idMaster)
@@ -7316 +7527 @@
 
     /* Set the master TSC as the initiator. */
-    while (ASMAtomicCmpXchgU32(&pDevExt->idTscDeltaInitiator, idMaster, NIL_RTCPUID) == false)
+    while (!ASMAtomicCmpXchgU32(&pDevExt->idTscDeltaInitiator, idMaster, NIL_RTCPUID))
     {
         /*
@@ -7333 +7544 @@
         if (RT_SUCCESS(rc))
         {
-            if (RT_UNLIKELY(pGipCpuWorker->i64TSCDelta == INT64_MAX))
+            if (RT_LIKELY(pGipCpuWorker->i64TSCDelta != INT64_MAX))
+            {
+                /*
+                 * Work the TSC delta applicability rating.  It starts
+                 * optimistic in supdrvGipInit, we downgrade it here.
+                 */
+                SUPGIPUSETSCDELTA enmRating;
+                if (   pGipCpuWorker->i64TSCDelta >  GIP_TSC_DELTA_THRESHOLD_ROUGHLY_ZERO
+                    || pGipCpuWorker->i64TSCDelta < -GIP_TSC_DELTA_THRESHOLD_ROUGHLY_ZERO)
+                    enmRating = SUPGIPUSETSCDELTA_NOT_ZERO;
+                else if (   pGipCpuWorker->i64TSCDelta >  GIP_TSC_DELTA_THRESHOLD_PRACTICALLY_ZERO
+                         || pGipCpuWorker->i64TSCDelta < -GIP_TSC_DELTA_THRESHOLD_PRACTICALLY_ZERO)
+                    enmRating = SUPGIPUSETSCDELTA_ROUGHLY_ZERO;
+                else
+                    enmRating = SUPGIPUSETSCDELTA_PRACTICALLY_ZERO;
+                if (pGip->enmUseTscDelta < enmRating)
+                {
+                    AssertCompile(sizeof(pGip->enmUseTscDelta) == sizeof(uint32_t));
+                    ASMAtomicWriteU32((uint32_t volatile *)&pGip->enmUseTscDelta, enmRating);
+                }
+            }
+            else
                 rc = VERR_SUPDRV_TSC_DELTA_MEASUREMENT_FAILED;
-            else if (   pGipCpuWorker->i64TSCDelta >  GIP_TSC_DELTA_APPLY_THRESHOLD
-                     || pGipCpuWorker->i64TSCDelta < -GIP_TSC_DELTA_APPLY_THRESHOLD)
-            {
-                pGip->fTscDeltasRoughlyInSync = false;
-            }
         }
     }
@@ -7373 +7600 @@
     uint32_t   cOnlineCpus    = pGip->cOnlineCpus;
 
-    Assert(GIP_ARE_TSC_DELTAS_APPLICABLE(pGip));
+    Assert(pGip->enmUseTscDelta > SUPGIPUSETSCDELTA_ZERO_CLAIMED);
 
     /*
@@ -7621 +7848 @@
     pCpu->u64TSC             = ASMReadTSC();
     pCpu->u64TSCSample       = GIP_TSC_DELTA_RSVD;
-    pCpu->i64TSCDelta        = GIP_ARE_TSC_DELTAS_APPLICABLE(pGip) ? INT64_MAX : 0;
+    pCpu->i64TSCDelta        = pGip->enmUseTscDelta > SUPGIPUSETSCDELTA_ZERO_CLAIMED ? INT64_MAX : 0;
 
     ASMAtomicWriteSize(&pCpu->enmState, SUPGIPCPUSTATE_INVALID);
@@ -7674 +7901 @@
     memset(pGip, 0, cbGip);
 
-    /*
-     * Record whether the host OS has already normalized inter-CPU deltas for the hardware TSC.
-     * We only bother with TSC-deltas on invariant CPUs for now.
-     */
-    pGip->fOsTscDeltasInSync = supdrvIsInvariantTsc() && supdrvOSAreTscDeltasInSync();
-
-    pGip->fTscDeltasRoughlyInSync = true;
     pGip->u32Magic                = SUPGLOBALINFOPAGE_MAGIC;
     pGip->u32Version              = SUPGLOBALINFOPAGE_VERSION;
     pGip->u32Mode                 = supdrvGipDetermineTscMode(pDevExt);
+    if (   pGip->u32Mode == SUPGIPMODE_INVARIANT_TSC
+        /*|| pGip->u32Mode == SUPGIPMODE_SYNC_TSC */)
+        pGip->enmUseTscDelta      = supdrvIsInvariantTsc() && supdrvOSAreTscDeltasInSync() /* Allow OS override (windows). */
+                                  ? SUPGIPUSETSCDELTA_ZERO_CLAIMED : SUPGIPUSETSCDELTA_PRACTICALLY_ZERO /* downgrade later */;
+    else
+        pGip->enmUseTscDelta      = SUPGIPUSETSCDELTA_NOT_APPLICABLE;
     pGip->cCpus                   = (uint16_t)cCpus;
     pGip->cPages                  = (uint16_t)(cbGip / PAGE_SIZE);
     pGip->u32UpdateHz             = uUpdateHz;
     pGip->u32UpdateIntervalNS     = uUpdateIntervalNS;
+    pGip->fGetGipCpu              = SUPGIPGETCPU_APIC_ID;
     RTCpuSetEmpty(&pGip->OnlineCpuSet);
     RTCpuSetEmpty(&pGip->PresentCpuSet);
@@ -7699 +7926 @@
     for (i = 0; i < RT_ELEMENTS(pGip->aiCpuFromCpuSetIdx); i++)
         pGip->aiCpuFromCpuSetIdx[i] = UINT16_MAX;
-
     for (i = 0; i < cCpus; i++)
         supdrvGipInitCpu(pDevExt, pGip, &pGip->aCPUs[i], u64NanoTS);
@@ -8066 +8292 @@
  *
  * @returns VBox status code.
- * @param   pDevExt             Pointer to the device instance data.
- * @param   pReq                Pointer to the TSC-delta measurement request.
- */
-static int supdrvIOCtl_TscDeltaMeasure(PSUPDRVDEVEXT pDevExt, PSUPTSCDELTAMEASURE pReq)
+ * @param   pDevExt         Pointer to the device instance data.
+ * @param   pSession        The support driver session.
+ * @param   pReq            Pointer to the TSC-delta measurement request.
+ */
+static int supdrvIOCtl_TscDeltaMeasure(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPTSCDELTAMEASURE pReq)
 {
     PSUPGLOBALINFOPAGE pGip;
     RTCPUID            idCpuWorker;
-    int                rc = VERR_CPU_NOT_FOUND;
+    int                rc;
     int16_t            cTries;
     RTMSINTERVAL       cMsWaitRetry;
@@ -8081 +8308 @@
      * Validate.
      */
-    AssertReturn(pDevExt, VERR_INVALID_PARAMETER);
-    AssertReturn(pReq, VERR_INVALID_PARAMETER);
-    AssertReturn(pDevExt->pGip, VERR_INVALID_PARAMETER);
+    AssertPtr(pDevExt); AssertPtr(pSession); AssertPtr(pReq); /* paranoia^2 */
+    if (pSession->GipMapObjR3 == NIL_RTR0MEMOBJ)
+        return VERR_WRONG_ORDER;
+    pGip = pDevExt->pGip;
+    AssertReturn(pGip, VERR_INTERNAL_ERROR_2);
+
     idCpuWorker = pReq->u.In.idCpu;
     if (idCpuWorker == NIL_RTCPUID)
         return VERR_INVALID_CPU_ID;
-
     cTries       = RT_MAX(pReq->u.In.cRetries + 1, 10);
     cMsWaitRetry = RT_MAX(pReq->u.In.cMsWaitRetry, 5);
+
+    /* 
+     * The request is a noop if the TSC delta isn't being used.
+     */
     pGip = pDevExt->pGip;
-
-    if (!GIP_ARE_TSC_DELTAS_APPLICABLE(pGip))
+    if (pGip->enmUseTscDelta <= SUPGIPUSETSCDELTA_ZERO_CLAIMED)
         return VINF_SUCCESS;
 
+    rc = VERR_CPU_NOT_FOUND;
     for (iCpu = 0; iCpu < pGip->cCpus; iCpu++)
     {
@@ -8174 +8407 @@
      * upset if the GIP is some different mode.
      */
-    if (GIP_ARE_TSC_DELTAS_APPLICABLE(pGip))
+    if (pGip->enmUseTscDelta > SUPGIPUSETSCDELTA_ZERO_CLAIMED)
     {
         uint32_t cTries = 0;

trunk/src/VBox/HostDrivers/Support/SUPDrvIOC.h ¶

@@ -215 +215 @@
  *          - Fix SUPTSCREAD padding (#if 0 -> #if 1).
  */
-#define SUPDRV_IOC_VERSION                              0x001e0000
+#define SUPDRV_IOC_VERSION                              0x001f0000
 
 /** SUP_IOCTL_COOKIE. */
@@ -1485 +1485 @@
  * Measure the TSC-delta between the specified CPU and the master TSC.
  *
+ * To call this I/O control, the client must first have mapped the GIP.
+ *
  * @{
  */
@@ -1511 +1513 @@
             /** Whether to do the measurement asynchronously (if possible). */
             bool            fAsync;
-            /** Padding for future. */
-            uint64_t        auPadding[3];
         } In;
     } u;
 } SUPTSCDELTAMEASURE, *PSUPTSCDELTAMEASURE;
 AssertCompileMemberAlignment(SUPTSCDELTAMEASURE, u, 8);
+AssertCompileSize(SUPTSCDELTAMEASURE, 6*4 + 4+1+1+1+1);
 /** @} */
 
@@ -1546 +1547 @@
             /** The APIC Id of the CPU where the TSC was read. */
             uint16_t        idApic;
-            /** Padding for future. */
-#if 0 /* Not correct for 32-bit gcc. */
-            uint16_t        auPadding[3 + 3*4];
-#else
-            uint64_t        auPadding[3];
-#endif
+            /** Explicit alignment padding. */
+            uint16_t        auPadding[3];
         } Out;
     } u;
 } SUPTSCREAD, *PSUPTSCREAD;
 AssertCompileMemberAlignment(SUPTSCREAD, u, 8);
-#if 0  /* Not correct for 32-bit gcc. */
-AssertCompileSize(SUPTSCREAD, 6*4 + 5*8);
+AssertCompileSize(SUPTSCREAD, 6*4 + 2*8);
+/** @} */
+
+#pragma pack()                          /* paranoia */
+
 #endif
-/** @} */
-
-#pragma pack()                          /* paranoia */
-
-#endif
-
+

trunk/src/VBox/HostDrivers/Support/testcase/tstGIP-2.cpp ¶

@@ -251 +251 @@
                     RTPrintf("tstGIP-2: offline: %lld\n", g_pSUPGlobalInfoPage->aCPUs[iCpu].i64TSCDelta);
 
-            RTPrintf("fTscDeltasRoughlyInSync: %RTbool\n", g_pSUPGlobalInfoPage->fTscDeltasRoughlyInSync);
-            RTPrintf("CPUID.Invariant-TSC    : %RTbool\n", tstIsInvariantTsc());
+            RTPrintf("tstGIP-2: enmUseTscDelta=%d  fGetGipCpu=%#x\n",
+                     g_pSUPGlobalInfoPage->enmUseTscDelta, g_pSUPGlobalInfoPage->fGetGipCpu);
             if (   uCpuHzRef
                 && cCpuHzOverallDevCnt)
             {
                 uint32_t uPct    = (uint32_t)(uCpuHzOverallDeviation * 100000 / cCpuHzOverallDevCnt / uCpuHzRef + 5);
+                RTPrintf("tstGIP-2: Average CpuHz deviation: %d.%02d%%\n",
+                         uPct / 1000, (uPct % 1000) / 10);
+
                 uint32_t uMaxPct = (uint32_t)(RT_ABS(iCpuHzMaxDeviation) * 100000 / uCpuHzRef + 5);
-                RTPrintf("Average CpuHz deviation: %d.%02d%%\n", uPct / 1000, (uPct % 1000) / 10);
-                RTPrintf("Maximum CpuHz deviation: %d.%02d%% (%RI64 ticks)\n", uMaxPct / 1000, (uMaxPct % 1000) / 10, iCpuHzMaxDeviation);
+                RTPrintf("tstGIP-2: Maximum CpuHz deviation: %d.%02d%% (%RI64 ticks)\n",
+                         uMaxPct / 1000, (uMaxPct % 1000) / 10, iCpuHzMaxDeviation);
             }
         }

trunk/src/VBox/Runtime/common/time/timesup.cpp ¶

@@ -168 +168 @@
         if (ASMCpuId_EDX(1) & X86_CPUID_FEATURE_EDX_SSE2)
             iWorker = pGip->u32Mode == SUPGIPMODE_INVARIANT_TSC
-                    ? !pGip->fOsTscDeltasInSync && !pGip->fTscDeltasRoughlyInSync
-                      ? RTTIMENANO_WORKER_LFENCE_INVAR_WITH_DELTA : RTTIMENANO_WORKER_LFENCE_INVAR_NO_DELTA
+                    ? pGip->enmUseTscDelta <= SUPGIPUSETSCDELTA_ROUGHLY_ZERO
+                      ? RTTIMENANO_WORKER_LFENCE_INVAR_NO_DELTA : RTTIMENANO_WORKER_LFENCE_INVAR_WITH_DELTA
                     : pGip->u32Mode == SUPGIPMODE_SYNC_TSC
-                    ? false /** @todo !pGip->fOsTscDeltasInSync && !pGip->fTscDeltasRoughlyInSync */
-                      ? RTTIMENANO_WORKER_LFENCE_SYNC_WITH_DELTA  : RTTIMENANO_WORKER_LFENCE_SYNC_NO_DELTA
+                    ? pGip->enmUseTscDelta <= SUPGIPUSETSCDELTA_ROUGHLY_ZERO
+                      ? RTTIMENANO_WORKER_LFENCE_SYNC_NO_DELTA  : RTTIMENANO_WORKER_LFENCE_SYNC_WITH_DELTA
                     : RTTIMENANO_WORKER_LFENCE_ASYNC;
         else
             iWorker = pGip->u32Mode == SUPGIPMODE_INVARIANT_TSC
-                    ? !pGip->fOsTscDeltasInSync && !pGip->fTscDeltasRoughlyInSync
-                      ? RTTIMENANO_WORKER_LEGACY_INVAR_WITH_DELTA : RTTIMENANO_WORKER_LEGACY_INVAR_NO_DELTA
+                    ? pGip->enmUseTscDelta <= SUPGIPUSETSCDELTA_ROUGHLY_ZERO
+                      ? RTTIMENANO_WORKER_LEGACY_INVAR_NO_DELTA : RTTIMENANO_WORKER_LEGACY_INVAR_WITH_DELTA
                     : pGip->u32Mode == SUPGIPMODE_SYNC_TSC
-                    ? false /** @todo !pGip->fOsTscDeltasInSync && !pGip->fTscDeltasRoughlyInSync */
-                      ? RTTIMENANO_WORKER_LEGACY_SYNC_WITH_DELTA  : RTTIMENANO_WORKER_LEGACY_SYNC_NO_DELTA
+                    ? pGip->enmUseTscDelta <= SUPGIPUSETSCDELTA_ROUGHLY_ZERO
+                      ? RTTIMENANO_WORKER_LEGACY_SYNC_NO_DELTA  : RTTIMENANO_WORKER_LEGACY_SYNC_WITH_DELTA
                     : RTTIMENANO_WORKER_LEGACY_ASYNC;
     }

trunk/src/VBox/Runtime/testcase/tstRTTime.cpp ¶

@@ -98 +98 @@
     else
     {
-        RTTestValue(hTest, "Total time delta", u64OSElapsedTS - u64RTElapsedTS, RTTESTUNIT_NS);
+        if (u64OSElapsedTS >= u64RTElapsedTS)
+            RTTestValue(hTest, "Total time delta", u64OSElapsedTS - u64RTElapsedTS, RTTESTUNIT_NS);
+        else
+            RTTestValue(hTest, "Total time delta", u64RTElapsedTS - u64OSElapsedTS, RTTESTUNIT_NS);
         RTTestPrintf(hTest, RTTESTLVL_INFO, "total time difference: u64OSElapsedTS=%#llx u64RTElapsedTS=%#llx delta=%lld\n",
                      u64OSElapsedTS, u64RTElapsedTS, u64OSElapsedTS - u64RTElapsedTS);

trunk/src/VBox/VMM/VMMR3/TM.cpp ¶

@@ -168 +168 @@
 *******************************************************************************/
 static bool                 tmR3HasFixedTSC(PVM pVM);
-static bool                 tmR3ReallyNeedDeltas(PSUPGLOBALINFOPAGE pGip);
 static const char *         tmR3GetTSCModeName(PVM pVM);
 static uint64_t             tmR3CalibrateTSC(PVM pVM);
@@ -231 +230 @@
      * as well and save costly world switches.
      */
-    pVM->tm.s.pvGIPR3 = (void *)g_pSUPGlobalInfoPage;
+    PSUPGLOBALINFOPAGE pGip = g_pSUPGlobalInfoPage;
+    pVM->tm.s.pvGIPR3 = (void *)pGip;
     AssertMsgReturn(pVM->tm.s.pvGIPR3, ("GIP support is now required!\n"), VERR_TM_GIP_REQUIRED);
-    AssertMsgReturn((g_pSUPGlobalInfoPage->u32Version >> 16) == (SUPGLOBALINFOPAGE_VERSION >> 16),
-                    ("Unsupported GIP version!\n"), VERR_TM_GIP_VERSION);
+    AssertMsgReturn((pGip->u32Version >> 16) == (SUPGLOBALINFOPAGE_VERSION >> 16),
+                    ("Unsupported GIP version %#x! (expected=%#x)\n", pGip->u32Version, SUPGLOBALINFOPAGE_VERSION),
+                    VERR_TM_GIP_VERSION);
 
     RTHCPHYS HCPhysGIP;
@@ -242 +243 @@
     RTGCPTR GCPtr;
 #ifdef SUP_WITH_LOTS_OF_CPUS
-    rc = MMR3HyperMapHCPhys(pVM, pVM->tm.s.pvGIPR3, NIL_RTR0PTR, HCPhysGIP, (size_t)g_pSUPGlobalInfoPage->cPages * PAGE_SIZE,
+    rc = MMR3HyperMapHCPhys(pVM, pVM->tm.s.pvGIPR3, NIL_RTR0PTR, HCPhysGIP, (size_t)pGip->cPages * PAGE_SIZE,
                             "GIP", &GCPtr);
 #else
@@ -257 +258 @@
 
     /* Check assumptions made in TMAllVirtual.cpp about the GIP update interval. */
-    if (    g_pSUPGlobalInfoPage->u32Magic == SUPGLOBALINFOPAGE_MAGIC
-        &&  g_pSUPGlobalInfoPage->u32UpdateIntervalNS >= 250000000 /* 0.25s */)
+    if (    pGip->u32Magic == SUPGLOBALINFOPAGE_MAGIC
+        &&  pGip->u32UpdateIntervalNS >= 250000000 /* 0.25s */)
         return VMSetError(pVM, VERR_TM_GIP_UPDATE_INTERVAL_TOO_BIG, RT_SRC_POS,
                           N_("The GIP update interval is too big. u32UpdateIntervalNS=%RU32 (u32UpdateHz=%RU32)"),
-                          g_pSUPGlobalInfoPage->u32UpdateIntervalNS, g_pSUPGlobalInfoPage->u32UpdateHz);
-    LogRel(("TM: GIP - u32Mode=%d (%s) u32UpdateHz=%u u32UpdateIntervalNS=%u\n", g_pSUPGlobalInfoPage->u32Mode,
-            SUPGetGIPModeName(g_pSUPGlobalInfoPage), g_pSUPGlobalInfoPage->u32UpdateHz,
-            g_pSUPGlobalInfoPage->u32UpdateIntervalNS));
-    LogRel(("TM: GIP - u64CpuHz=%#RX64 (%'RU64)\n", g_pSUPGlobalInfoPage->u64CpuHz, g_pSUPGlobalInfoPage->u64CpuHz));
+                          pGip->u32UpdateIntervalNS, pGip->u32UpdateHz);
+    LogRel(("TM: GIP - u32Mode=%d (%s) u32UpdateHz=%u u32UpdateIntervalNS=%u\n", pGip->u32Mode,
+            SUPGetGIPModeName(pGip), pGip->u32UpdateHz,
+            pGip->u32UpdateIntervalNS));
+    LogRel(("TM: GIP - u64CpuHz=%#RX64 (%'RU64)\n", pGip->u64CpuHz, pGip->u64CpuHz));
 
     /*
@@ -275 +276 @@
     if (ASMCpuId_EDX(1) & X86_CPUID_FEATURE_EDX_SSE2)
     {
-        if (g_pSUPGlobalInfoPage->u32Mode == SUPGIPMODE_INVARIANT_TSC)
-            pVM->tm.s.pfnVirtualGetRawR3 = tmR3ReallyNeedDeltas(g_pSUPGlobalInfoPage)
-                                         ? RTTimeNanoTSLFenceInvariantWithDelta : RTTimeNanoTSLFenceInvariantNoDelta;
-        else if (g_pSUPGlobalInfoPage->u32Mode == SUPGIPMODE_SYNC_TSC)
-            pVM->tm.s.pfnVirtualGetRawR3 = false /** @todo tmR3ReallyNeedDeltas(g_pSUPGlobalInfoPage) */
-                                         ? RTTimeNanoTSLFenceSyncWithDelta      : RTTimeNanoTSLFenceSyncNoDelta;
+        if (pGip->u32Mode == SUPGIPMODE_INVARIANT_TSC)
+            pVM->tm.s.pfnVirtualGetRawR3 = pGip->enmUseTscDelta <= SUPGIPUSETSCDELTA_ROUGHLY_ZERO
+                                         ? RTTimeNanoTSLFenceInvariantNoDelta : RTTimeNanoTSLFenceInvariantWithDelta;
+        else if (pGip->u32Mode == SUPGIPMODE_SYNC_TSC)
+            pVM->tm.s.pfnVirtualGetRawR3 = pGip->enmUseTscDelta <= SUPGIPUSETSCDELTA_ROUGHLY_ZERO
+                                         ? RTTimeNanoTSLFenceSyncNoDelta      : RTTimeNanoTSLFenceSyncWithDelta;
         else
             pVM->tm.s.pfnVirtualGetRawR3 = RTTimeNanoTSLFenceAsync;
@@ -286 +287 @@
     else
     {
-        if (g_pSUPGlobalInfoPage->u32Mode == SUPGIPMODE_INVARIANT_TSC)
-            pVM->tm.s.pfnVirtualGetRawR3 = tmR3ReallyNeedDeltas(g_pSUPGlobalInfoPage)
-                                         ? RTTimeNanoTSLegacyInvariantWithDelta : RTTimeNanoTSLegacyInvariantNoDelta;
-        else if (g_pSUPGlobalInfoPage->u32Mode == SUPGIPMODE_SYNC_TSC)
-            pVM->tm.s.pfnVirtualGetRawR3 = false /** @todo tmR3ReallyNeedDeltas(g_pSUPGlobalInfoPage) */
-                                         ? RTTimeNanoTSLegacySyncWithDelta      : RTTimeNanoTSLegacySyncNoDelta;
+        if (pGip->u32Mode == SUPGIPMODE_INVARIANT_TSC)
+            pVM->tm.s.pfnVirtualGetRawR3 = pGip->enmUseTscDelta <= SUPGIPUSETSCDELTA_ROUGHLY_ZERO
+                                         ? RTTimeNanoTSLegacyInvariantNoDelta   : RTTimeNanoTSLegacyInvariantWithDelta;
+        else if (pGip->u32Mode == SUPGIPMODE_SYNC_TSC)
+            pVM->tm.s.pfnVirtualGetRawR3 = pGip->enmUseTscDelta <= SUPGIPUSETSCDELTA_ROUGHLY_ZERO
+                                         ? RTTimeNanoTSLegacySyncNoDelta        : RTTimeNanoTSLegacySyncWithDelta;
         else
             pVM->tm.s.pfnVirtualGetRawR3 = RTTimeNanoTSLegacyAsync;
@@ -619 +620 @@
      * Dump the GIPCPU TSC-deltas, iterate using the Apic Id to get master at the beginning in most cases.
      */
-    LogRel(("TM: GIP - fTscDeltasRoughlyInSync=%RTbool\n", g_pSUPGlobalInfoPage->fTscDeltasRoughlyInSync));
-    unsigned cGipCpus = RT_ELEMENTS(g_pSUPGlobalInfoPage->aiCpuFromApicId);
-    for (unsigned i = 0; i < cGipCpus; i++)
-    {
-        uint16_t iCpu  = g_pSUPGlobalInfoPage->aiCpuFromApicId[i];
+    LogRel(("TM: GIP - enmUseTscDelta=%d fGetGipCpu=%#x cCpus=%#x\n",
+            pGip->enmUseTscDelta, pGip->fGetGipCpu, pGip->cCpus));
+    for (uint32_t i = 0; i < RT_ELEMENTS(pGip->aiCpuFromApicId); i++)
+    {
+        uint16_t iCpu = pGip->aiCpuFromApicId[i];
 #if 1
         if (iCpu != UINT16_MAX)
-            LogRel(("TM: GIP - CPU[%d]: idApic=%d i64TSCDelta=%RI64\n", g_pSUPGlobalInfoPage->aCPUs[iCpu].idCpu,
-                    g_pSUPGlobalInfoPage->aCPUs[iCpu].idApic, g_pSUPGlobalInfoPage->aCPUs[iCpu].i64TSCDelta));
+            LogRel(("TM: GIP - CPU[%d]: idApic=%d i64TSCDelta=%RI64\n", pGip->aCPUs[iCpu].idCpu,
+                    pGip->aCPUs[iCpu].idApic, pGip->aCPUs[iCpu].i64TSCDelta));
 #else
         /* Dump 2 entries per line, saves vertical space in release log but more dumps bytes due to formatting. */
@@ -633 +634 @@
         for (unsigned k = i + 1; k < cGipCpus; k++)
         {
-            iCpu2 = g_pSUPGlobalInfoPage->aiCpuFromApicId[k];
+            iCpu2 = pGip->aiCpuFromApicId[k];
             if (iCpu2 != UINT16_MAX)
             {
@@ -644 +645 @@
         {
             LogRel(("TM: GIP - CPU[%d]: idApic=%d i64TSCDelta=%-4lld CPU[%d]: idApic=%d i64TSCDelta=%lld\n",
-                    g_pSUPGlobalInfoPage->aCPUs[iCpu].idCpu, g_pSUPGlobalInfoPage->aCPUs[iCpu].idApic,
-                    g_pSUPGlobalInfoPage->aCPUs[iCpu].i64TSCDelta, g_pSUPGlobalInfoPage->aCPUs[iCpu2].idCpu,
-                    g_pSUPGlobalInfoPage->aCPUs[iCpu2].idApic, g_pSUPGlobalInfoPage->aCPUs[iCpu2].i64TSCDelta));
+                    pGip->aCPUs[iCpu].idCpu, pGip->aCPUs[iCpu].idApic,
+                    pGip->aCPUs[iCpu].i64TSCDelta, pGip->aCPUs[iCpu2].idCpu,
+                    pGip->aCPUs[iCpu2].idApic, pGip->aCPUs[iCpu2].i64TSCDelta));
         }
         else if (iCpu != UINT16_MAX)
-            LogRel(("TM: GIP - CPU[%d]: idApic=%d i64TSCDelta=%lld\n", g_pSUPGlobalInfoPage->aCPUs[iCpu].idCpu,
-                    g_pSUPGlobalInfoPage->aCPUs[iCpu].idApic));
+            LogRel(("TM: GIP - CPU[%d]: idApic=%d i64TSCDelta=%lld\n", pGip->aCPUs[iCpu].idCpu,
+                    pGip->aCPUs[iCpu].idApic));
 #endif
     }
@@ -941 +942 @@
     }
     return false;
-}
-
-
-/**
- * Checks if we really need to apply the delta values when calculating time.
- *
- * Getting the delta for a CPU is _very_ expensive, it more than doubles the
- * execution time for RTTimeNanoTS.
- *
- * @returns true if deltas needs to be applied, false if not.
- * @param   pGip                The GIP.
- *
- * @remarks If you change this, make sure to also change
- *          rtTimeNanoTsInternalReallyNeedDeltas().
- */
-static bool tmR3ReallyNeedDeltas(PSUPGLOBALINFOPAGE pGip)
-{
-    return !pGip->fOsTscDeltasInSync && !pGip->fTscDeltasRoughlyInSync;
-#if 0
-    if (!pGip->fOsTscDeltasInSync)
-    {
-        uint32_t i = pGip->cCpus;
-        while (i-- > 0)
-            if (   pGip->aCPUs[i].enmState == SUPGIPCPUSTATE_ONLINE
-                && (   pGip->aCPUs[i].i64TSCDelta > 384
-                    || pGip->aCPUs[i].i64TSCDelta < -384) )
-                return true;
-    }
-    return false;
-#endif
 }