Changeset 54357 in vbox

Timestamp:

Feb 22, 2015 7:14:39 PM (10 years ago)

Author:

vboxsync

Message:

SUPDrvGip.cpp: First part of the less noisy tsc-delta-measurment synchronization w/ timeout revamp.

File:

• trunk/src/VBox/HostDrivers/Support/SUPDrvGip.cpp (modified) (25 diffs)

trunk/src/VBox/HostDrivers/Support/SUPDrvGip.cpp

@@ -2550 +2550 @@
     uint64_t                    au64CacheLinePaddingBefore[GIP_TSC_DELTA_CACHE_LINE_SIZE / sizeof(uint64_t)];
     /** The synchronization variable, holds values GIP_TSC_DELTA_SYNC_*. */
-    volatile uint32_t           uVar1;
+    volatile uint32_t           uSyncVar;
     /** Unused. */
-    volatile uint32_t           uVar2;
-
-    /** Start RDTSC value.  This does not need to be in its own cache line, it's
-     * just put here to save stack space. */
+    volatile uint32_t           u32Padding;
+
+    /** Padding to make sure the uVar1 is in its own cache line. */
+    uint64_t                    au64CacheLinePaddingAfter[GIP_TSC_DELTA_CACHE_LINE_SIZE / sizeof(uint64_t) - 1];
+
+    /** Start RDTSC value.  Put here mainly to save stack space. */
     uint64_t                    uTscStart;
-    /** Max number of ticks we can allow to elapse in the RTMpOn callback.
-     * This is estimated from the CPU frequency...  */
-    uint64_t                    cMaxTicks;
-
-    /** Padding to make sure the uVar1 is in its own cache line. */
-    uint64_t                    au64CacheLinePaddingAfter[GIP_TSC_DELTA_CACHE_LINE_SIZE / sizeof(uint64_t) - 2];
 } SUPTSCDELTASYNC2;
 AssertCompileSize(SUPTSCDELTASYNC2, GIP_TSC_DELTA_CACHE_LINE_SIZE * 2 + sizeof(uint64_t));
@@ -2575 +2571 @@
 {
     /** The device extension.   */
-    PSUPDRVDEVEXT           pDevExt;
+    PSUPDRVDEVEXT               pDevExt;
     /** Pointer to the GIP CPU array entry for the worker. */
-    PSUPGIPCPU              pWorker;
+    PSUPGIPCPU                  pWorker;
     /** Pointer to the GIP CPU array entry for the master. */
-    PSUPGIPCPU              pMaster;
+    PSUPGIPCPU                  pMaster;
     /** Pointer to the master's synchronization struct (on stack). */
-    PSUPTSCDELTASYNC2       pSyncMaster;
+    PSUPTSCDELTASYNC2 volatile  pSyncMaster;
     /** Pointer to the worker's synchronization struct (on stack). */
-    PSUPTSCDELTASYNC2       pSyncWorker;
+    PSUPTSCDELTASYNC2 volatile  pSyncWorker;
+    /** The maximum number of ticks to spend in supdrvMeasureTscDeltaCallback.
+     * (This is what we need a rough TSC frequency for.)  */
+    uint64_t                    cMaxTscTicks;
+    /** Used to abort synchronization setup. */
+    bool volatile               fAbortSetup;
 
 #if 0
@@ -2611 +2612 @@
  * @{
  */
-#define TSCDELTA_MASTER_SYNC_BEFORE(a_pTscDeltaSync) \
+#define TSCDELTA_MASTER_SYNC_BEFORE(a_pSync1, a_pMySync, a_pOtherSync) \
     do {\
-        ASMAtomicWriteU32(&(a_pTscDeltaSync)->u, GIP_TSC_DELTA_SYNC_START); \
+        ASMAtomicWriteU32(&(a_pSync1)->u, GIP_TSC_DELTA_SYNC_START); \
         \
         /* Disable interrupts only in the master for as short a period \
@@ -2619 +2620 @@
         uFlags = ASMIntDisableFlags(); \
         \
-        while (ASMAtomicReadU32(&(a_pTscDeltaSync)->u) == GIP_TSC_DELTA_SYNC_START) \
+        while (ASMAtomicReadU32(&(a_pSync1)->u) == GIP_TSC_DELTA_SYNC_START) \
         { /* nothing */ } \
     } while (0)
-#define TSCDELTA_MASTER_SYNC_AFTER(a_pTscDeltaSync) \
+#define TSCDELTA_MASTER_SYNC_AFTER(a_pSync1, a_pMySync, a_pOtherSync) \
     do {\
         /* Sync up with worker. */ \
         ASMSetFlags(uFlags); \
         \
-        while (ASMAtomicReadU32(&(a_pTscDeltaSync)->u) != GIP_TSC_DELTA_SYNC_WORKER_DONE) \
+        while (ASMAtomicReadU32(&(a_pSync1)->u) != GIP_TSC_DELTA_SYNC_WORKER_DONE) \
         { /* nothing */ } \
     } while (0)
-#define TSCDELTA_MASTER_KICK_OTHER_OUT_OF_AFTER(a_pTscDeltaSync) \
+#define TSCDELTA_MASTER_KICK_OTHER_OUT_OF_AFTER(a_pSync1, a_pMySync, a_pOtherSync) \
     do {\
-        ASMAtomicWriteU32(&(a_pTscDeltaSync)->u, GIP_TSC_DELTA_SYNC_STOP); \
+        ASMAtomicWriteU32(&(a_pSync1)->u, GIP_TSC_DELTA_SYNC_STOP); \
     } while (0)
 
-#define TSCDELTA_OTHER_SYNC_BEFORE(a_pTscDeltaSync, a_MidSyncExpr) \
+#define TSCDELTA_OTHER_SYNC_BEFORE(a_pSync1, a_pMySync, a_pOtherSync, a_MidSyncExpr) \
     do { \
-        while (ASMAtomicReadU32(&(a_pTscDeltaSync)->u) != GIP_TSC_DELTA_SYNC_START) \
+        while (ASMAtomicReadU32(&(a_pSync1)->u) != GIP_TSC_DELTA_SYNC_START) \
         { /* nothing */ } \
         a_MidSyncExpr; \
-        ASMAtomicWriteU32(&(a_pTscDeltaSync)->u, GIP_TSC_DELTA_SYNC_WORKER_READY); \
+        ASMAtomicWriteU32(&(a_pSync1)->u, GIP_TSC_DELTA_SYNC_WORKER_READY); \
     } while (0)
-#define TSCDELTA_OTHER_SYNC_AFTER(a_pTscDeltaSync) \
+#define TSCDELTA_OTHER_SYNC_AFTER(a_pSync1, a_pMySync, a_pOtherSync) \
     do { \
         /* Tell master we're done collecting our data. */ \
-        ASMAtomicWriteU32(&(a_pTscDeltaSync)->u, GIP_TSC_DELTA_SYNC_WORKER_DONE); \
+        ASMAtomicWriteU32(&(a_pSync1)->u, GIP_TSC_DELTA_SYNC_WORKER_DONE); \
         \
         /* Wait for the master to process the data. */ \
-        while (ASMAtomicReadU32(&(a_pTscDeltaSync)->u) == GIP_TSC_DELTA_SYNC_WORKER_DONE) \
+        while (ASMAtomicReadU32(&(a_pSync1)->u) == GIP_TSC_DELTA_SYNC_WORKER_DONE) \
             ASMNopPause(); \
     } while (0)
@@ -2682 +2683 @@
  *
  * @param   pArgs               The argument/state data.
- * @param   pSync               The synchronization structure
+ * @param   pSync1              The synchronization structure
  *                              (pDevExt->pTscDeltaSync).
  * @param   fIsMaster           Set if master, clear if worker.
  * @param   iTry                The attempt number.
  */
-static void supdrvTscDeltaMethod1Loop(PSUPDRVGIPTSCDELTARGS pArgs, PSUPTSCDELTASYNC pSync, bool fIsMaster, uint32_t iTry)
+static void supdrvTscDeltaMethod1Loop(PSUPDRVGIPTSCDELTARGS pArgs, PSUPTSCDELTASYNC pSync1,
+                                      PSUPTSCDELTASYNC2 pMySync, PSUPTSCDELTASYNC2 pOtherSync, bool fIsMaster, uint32_t iTry)
 {
     PSUPGIPCPU  pGipCpuWorker   = pArgs->pWorker;
@@ -2706 +2708 @@
                       ("%#llx idMaster=%#x idWorker=%#x (idGipMaster=%#x)\n",
                        pGipCpuMaster->u64TSCSample, pGipCpuMaster->idCpu, pGipCpuWorker->idCpu, pArgs->pDevExt->idGipMaster));
-            TSCDELTA_MASTER_SYNC_BEFORE(pSync);
+            TSCDELTA_MASTER_SYNC_BEFORE(pSync1, pMySync, pOtherSync);
 
             do
@@ -2714 +2716 @@
             } while (pGipCpuMaster->u64TSCSample == GIP_TSC_DELTA_RSVD);
 
-            TSCDELTA_MASTER_SYNC_AFTER(pSync);
+            TSCDELTA_MASTER_SYNC_AFTER(pSync1, pMySync, pOtherSync);
 
             /* Process the data. */
@@ -2732 +2734 @@
             /* Reset our TSC sample and tell the worker to move on. */
             ASMAtomicWriteU64(&pGipCpuMaster->u64TSCSample, GIP_TSC_DELTA_RSVD);
-            TSCDELTA_MASTER_KICK_OTHER_OUT_OF_AFTER(pSync);
+            TSCDELTA_MASTER_KICK_OTHER_OUT_OF_AFTER(pSync1, pMySync, pOtherSync);
         }
         else
@@ -2744 +2746 @@
 
             ASMAtomicReadU64(&pGipCpuMaster->u64TSCSample);     /* Warm the cache line. */
-            TSCDELTA_OTHER_SYNC_BEFORE(pSync, Assert(pGipCpuMaster->u64TSCSample == GIP_TSC_DELTA_RSVD));
+            TSCDELTA_OTHER_SYNC_BEFORE(pSync1, pMySync, pOtherSync, Assert(pGipCpuMaster->u64TSCSample == GIP_TSC_DELTA_RSVD));
 
             /*
@@ -2779 +2781 @@
             }
 
-            TSCDELTA_OTHER_SYNC_AFTER(pSync);
+            TSCDELTA_OTHER_SYNC_AFTER(pSync1, pMySync, pOtherSync);
         }
     }
@@ -2948 +2950 @@
  *
  * @param   pArgs               The argument/state data.
- * @param   pSync               The synchronization structure
+ * @param   pSync1               The synchronization structure
  *                              (pDevExt->pTscDeltaSync).
  * @param   fIsMaster           Set if master, clear if worker.
  * @param   iTry                The attempt number.
  */
-static void supdrvTscDeltaMethod2Loop(PSUPDRVGIPTSCDELTARGS pArgs, PSUPTSCDELTASYNC pSync, bool fIsMaster, uint32_t iTry)
+static void supdrvTscDeltaMethod2Loop(PSUPDRVGIPTSCDELTARGS pArgs, PSUPTSCDELTASYNC pSync1,
+                                      PSUPTSCDELTASYNC2 pMySync, PSUPTSCDELTASYNC2 pOtherSync, bool fIsMaster, uint32_t iTry)
 {
     unsigned iLoop;
@@ -3000 +3003 @@
              * Sync up with the worker and collect data.
              */
-            TSCDELTA_MASTER_SYNC_BEFORE(pSync);
+            TSCDELTA_MASTER_SYNC_BEFORE(pSync1, pMySync, pOtherSync);
             supdrvTscDeltaMethod2CollectData(pArgs->M2.pMasterData, &pArgs->M2.pWorkerData->iCurSeqNo, pArgs->M2.fLagMaster);
-            TSCDELTA_MASTER_SYNC_AFTER(pSync);
+            TSCDELTA_MASTER_SYNC_AFTER(pSync1, pMySync, pOtherSync);
 
             /*
@@ -3012 +3015 @@
                 supdrvTscDeltaMethod2ProcessDataOnMaster(pArgs, iLoop);
 
-            TSCDELTA_MASTER_KICK_OTHER_OUT_OF_AFTER(pSync);
+            TSCDELTA_MASTER_KICK_OTHER_OUT_OF_AFTER(pSync1, pMySync, pOtherSync);
         }
         else
@@ -3019 +3022 @@
              * The worker.
              */
-            TSCDELTA_OTHER_SYNC_BEFORE(pSync, (void)0);
+            TSCDELTA_OTHER_SYNC_BEFORE(pSync1, pMySync, pOtherSync, (void)0);
             supdrvTscDeltaMethod2CollectData(pArgs->M2.pWorkerData, &pArgs->M2.pMasterData->iCurSeqNo, pArgs->M2.fLagWorker);
-            TSCDELTA_OTHER_SYNC_AFTER(pSync);
+            TSCDELTA_OTHER_SYNC_AFTER(pSync1, pMySync, pOtherSync);
         }
 
@@ -3068 +3071 @@
 
 /** Prestart wait. */
-#define GIP_TSC_DELTA_SYNC2_PRESTART_WAIT    UINT32_C(0xffe)
-
-/** Start measurement of TSC delta. */
-#define GIP_TSC_DELTA_SYNC2_START            UINT32_C(1)
-/** Worker thread is ready for reading the TSC. */
-#define GIP_TSC_DELTA_SYNC2_WORKER_READY     UINT32_C(2)
-/** Worker thread is done updating TSC delta info. */
-#define GIP_TSC_DELTA_SYNC2_WORKER_DONE      UINT32_C(3)
-/** When IPRT is isn't concurrent safe: Master is ready and will wait for worker
- *  with a timeout. */
-#define GIP_TSC_DELTA_SYNC2_PRESTART_MASTER  UINT32_C(4)
-
-
-/**
- * Callback used by supdrvMeasureInitialTscDeltas() to read the TSC on two CPUs
+#define GIP_TSC_DELTA_SYNC2_PRESTART_WAIT    UINT32_C(0x0ffe)
+/** Prestart aborted. */
+#define GIP_TSC_DELTA_SYNC2_PRESTART_ABORT   UINT32_C(0x0fff)
+/** Start testing. */
+#define GIP_TSC_DELTA_SYNC2_START            UINT32_C(0x1000)
+
+
+/** The other party won't touch the sync struct ever again. */
+#define GIP_TSC_DELTA_SYNC2_FINAL            UINT32_C(0x1fff)
+
+
+
+static int supdrvMeasureTscDeltaCallbackAbortSyncSetup(PSUPDRVGIPTSCDELTARGS pArgs, PSUPTSCDELTASYNC2 pMySync,
+                                                       bool fIsMaster, bool fTimeout)
+{
+    PSUPTSCDELTASYNC2 volatile *ppMySync    = fIsMaster ? &pArgs->pSyncMaster : &pArgs->pSyncWorker;
+    PSUPTSCDELTASYNC2 volatile *ppOtherSync = fIsMaster ? &pArgs->pSyncWorker : &pArgs->pSyncMaster;
+#if defined(DEBUG_bird) && defined(RT_OS_WINDOWS)
+    uint32_t iTry = 0;
+#endif
+
+    /*
+     * Clear our sync pointer and make sure the abort flag is set.
+     */
+    ASMAtomicWriteNullPtr(ppMySync);
+    ASMAtomicWriteBool(&pArgs->fAbortSetup, true);
+
+    /*
+     * Make sure the other party is out of there and won't be touching our
+     * sync state again (would cause stack corruption).
+     */
+    while (ASMAtomicReadPtrT(ppOtherSync, PSUPTSCDELTASYNC2) != NULL)
+    {
+        ASMNopPause();
+        ASMNopPause();
+        ASMNopPause();
+#if defined(DEBUG_bird) && defined(RT_OS_WINDOWS)
+if (++iTry == 0) __debugbreak();
+#endif
+    }
+
+    return 0;
+}
+
+
+/**
+ * This is used by supdrvMeasureInitialTscDeltas() to read the TSC on two CPUs
  * and compute the delta between them.
  *
+ * To reduce code size a good when timeout handling was added, a dummy return
+ * value had to be added (saves 1-3 lines per timeout case), thus this
+ * 'Unwrapped' function and the dummy 0 return value.
+ *
+ * @returns 0 (dummy, ignored)
  * @param   idCpu       The CPU we are current scheduled on.
- * @param   pvUser1     Pointer to a parameter package (SUPDRVGIPTSCDELTARGS).
- * @param   pvUser2     Unused.
+ * @param   pArgs       Pointer to a parameter package.
  *
  * @remarks Measuring TSC deltas between the CPUs is tricky because we need to
@@ -3095 +3134 @@
  *          doing this on x86 CPUs.
  */
-static DECLCALLBACK(void) supdrvMeasureTscDeltaCallback(RTCPUID idCpu, void *pvUser1, void *pvUser2)
-{
-    PSUPDRVGIPTSCDELTARGS   pArgs = (PSUPDRVGIPTSCDELTARGS)pvUser1;
-    PSUPDRVDEVEXT           pDevExt          = pArgs->pDevExt;
-    PSUPTSCDELTASYNC        pSync            = pDevExt->pTscDeltaSync;
-    PSUPGIPCPU              pGipCpuWorker    = pArgs->pWorker;
-    PSUPGIPCPU              pGipCpuMaster    = pArgs->pMaster;
-    bool const              fIsMaster        = idCpu == pGipCpuMaster->idCpu;
-    uint32_t                iTry;
-#if 0
-    PSUPTSCDELTASYNC2       pOtherSync;
-    SUPTSCDELTASYNC2        MySync;
-#endif
+static int supdrvMeasureTscDeltaCallbackUnwrapped(RTCPUID idCpu, PSUPDRVGIPTSCDELTARGS pArgs)
+{
+    PSUPDRVDEVEXT               pDevExt          = pArgs->pDevExt;
+    PSUPTSCDELTASYNC            pSync1           = pDevExt->pTscDeltaSync;
+    PSUPGIPCPU                  pGipCpuWorker    = pArgs->pWorker;
+    PSUPGIPCPU                  pGipCpuMaster    = pArgs->pMaster;
+    bool const                  fIsMaster        = idCpu == pGipCpuMaster->idCpu;
+    uint32_t                    iTry;
+    PSUPTSCDELTASYNC2 volatile *ppMySync         = fIsMaster ? &pArgs->pSyncMaster : &pArgs->pSyncWorker;
+    PSUPTSCDELTASYNC2 volatile *ppOtherSync      = fIsMaster ? &pArgs->pSyncWorker : &pArgs->pSyncMaster;
+    SUPTSCDELTASYNC2            MySync;
+    PSUPTSCDELTASYNC2           pOtherSync;
 
     /* A bit of paranoia first. */
     if (!pGipCpuMaster || !pGipCpuWorker)
-        return;
+        return 0;
 
     /*
@@ -3118 +3156 @@
     if (   !fIsMaster
         && idCpu != pGipCpuWorker->idCpu)
-        return;
-
-#if 0
+        return 0;
+
     /*
      * Set up my synchronization stuff and wait for the other party to show up.
-     * We don't wait forever since the other party may have gone fishing after
-     * we checked it out in supdrvMeasureTscDeltaOne, and then there is of course
-     * windows and it's BSOD if we waste too much time here.
-     */
+     *
+     * We don't wait forever since the other party may be off fishing (offline,
+     * spinning with ints disables, whatever), we must play nice to the rest of
+     * the system as this context generally isn't one in which we will get
+     * preempted and we may hold up a number of lower priority interrupts.
+     */
+    ASMAtomicWriteU32(&MySync.uSyncVar, GIP_TSC_DELTA_SYNC2_PRESTART_WAIT);
+    ASMAtomicWritePtr(ppMySync, &MySync);
+    MySync.uTscStart = ASMReadTSC();
+
+    /* Look for the partner, might not be here yet... Special abort considerations. */
+    iTry = 0;
+    while ((pOtherSync = ASMAtomicReadPtrT(ppOtherSync, PSUPTSCDELTASYNC2)) == NULL)
+    {
+        ASMNopPause();
+        if (   ASMAtomicReadBool(&pArgs->fAbortSetup)
+            || !RTMpIsCpuOnline(fIsMaster ? pGipCpuWorker->idCpu : pGipCpuWorker->idCpu) )
+            return supdrvMeasureTscDeltaCallbackAbortSyncSetup(pArgs, &MySync, fIsMaster, false /*fTimeout*/);
+        if (   (iTry++ & 0xff) == 0
+            && ASMReadTSC() - MySync.uTscStart > pArgs->cMaxTscTicks)
+            return supdrvMeasureTscDeltaCallbackAbortSyncSetup(pArgs, &MySync, fIsMaster, true /*fTimeout*/);
+#if defined(DEBUG_bird) && defined(RT_OS_WINDOWS)
+if (iTry == 0) __debugbreak();
+#endif
+        ASMNopPause();
+    }
+
+    /* I found my partner, waiting to be found... Special abort considerations. */
     if (fIsMaster)
-    {
-        MySync.uVar1 = GIP_TSC_DELTA_SYNC2_PRESTART_WAIT;
-        ASMSerializeInstruction(); ASMCompilerBarrier();
-        ASMAtomicWritePtr(&pArgs->pSyncMaster, &MySync);
-    }
-    else
-    {
-        MySync.uVar1 = GIP_TSC_DELTA_SYNC2_PRESTART_WAIT;
-        ASMSerializeInstruction(); ASMCompilerBarrier();
-        ASMAtomicWritePtr(&pArgs->pSyncWorker, &MySync);
-    }
-
-    MySync.uTscStart = ASMReadTSC();
-    MySync.cMaxTicks = u64CpuHz
-
-    while ((pOtherSync = ASMAtomicReadPtr((void * volatile *)(fIsMaster ? &pArgs->pSyncWorker : &pArgs->pSyncMaster))) != NULL)
-    {
-        uint32_t cInner = 10240;
-        while (   cInner-- > 0
-               && ASMAtomicUoReadU32(MySync.uVar1) == GIP_TSC_DELTA_SYNC2_PRESTART_WAIT)
-            ASMNopPause();
-
-    }
+        if (!ASMAtomicCmpXchgU32(&pOtherSync->uSyncVar, GIP_TSC_DELTA_SYNC2_START, GIP_TSC_DELTA_SYNC2_PRESTART_WAIT)) /* parnaoia */
+            return supdrvMeasureTscDeltaCallbackAbortSyncSetup(pArgs, &MySync, fIsMaster, false /*fTimeout*/);
+
+    iTry = 0;
+    while (ASMAtomicReadU32(&MySync.uSyncVar) == GIP_TSC_DELTA_SYNC2_PRESTART_WAIT)
+    {
+        ASMNopPause();
+        if (ASMAtomicReadBool(&pArgs->fAbortSetup))
+            return supdrvMeasureTscDeltaCallbackAbortSyncSetup(pArgs, &MySync, fIsMaster, false /*fTimeout*/);
+        if (   (iTry++ & 0xff) == 0
+            && ASMReadTSC() - MySync.uTscStart > pArgs->cMaxTscTicks)
+        {
+            if (   fIsMaster
+                && !ASMAtomicCmpXchgU32(&MySync.uSyncVar, GIP_TSC_DELTA_SYNC2_PRESTART_ABORT, GIP_TSC_DELTA_SYNC2_PRESTART_WAIT))
+                break; /* race #1: slave has moved on, handle timeout in loop instead. */
+            return supdrvMeasureTscDeltaCallbackAbortSyncSetup(pArgs, &MySync, fIsMaster, true /*fTimeout*/);
+        }
+#if defined(DEBUG_bird) && defined(RT_OS_WINDOWS)
+if (iTry == 0) __debugbreak();
 #endif
-
-
-    /* If the IPRT API isn't concurrent safe, the master and worker wait for each other
-       with a timeout to avoid deadlocking the entire system. */
-    if (!RTMpOnAllIsConcurrentSafe())
-    {
-        /** @todo This was introduced for Windows, but since Windows doesn't use this
-         *        code path any longer (as DPC timeouts BSOD regardless of interrupts,
-         *        see @bugref{6710} comment 81), eventually phase it out. */
-        uint64_t       uTscNow;
-        uint64_t       uTscStart;
-        uint64_t const cWaitTicks = 130000;  /* Arbitrary value, can be tweaked later. */
-
-        ASMSerializeInstruction();
-        uTscStart = ASMReadTSC();
-        if (fIsMaster)
-        {
-            ASMAtomicWriteU32(&pDevExt->pTscDeltaSync->u, GIP_TSC_DELTA_SYNC_PRESTART_MASTER);
-            while (ASMAtomicReadU32(&pDevExt->pTscDeltaSync->u) != GIP_TSC_DELTA_SYNC_PRESTART_WORKER)
-            {
-                ASMSerializeInstruction();
-                uTscNow = ASMReadTSC();
-                if (uTscNow - uTscStart > cWaitTicks)
-                {
-                    /* Set the worker delta to indicate failure, not the master. */
-                    ASMAtomicWriteS64(&pGipCpuWorker->i64TSCDelta, INT64_MAX);
-                    return;
-                }
-
-                ASMNopPause();
-            }
-        }
-        else
-        {
-            while (ASMAtomicReadU32(&pDevExt->pTscDeltaSync->u) != GIP_TSC_DELTA_SYNC_PRESTART_MASTER)
-            {
-                ASMSerializeInstruction();
-                uTscNow = ASMReadTSC();
-                if (uTscNow - uTscStart > cWaitTicks)
-                {
-                    ASMAtomicWriteS64(&pGipCpuWorker->i64TSCDelta, INT64_MAX);
-                    return;
-                }
-
-                ASMNopPause();
-            }
-            ASMAtomicWriteU32(&pDevExt->pTscDeltaSync->u, GIP_TSC_DELTA_SYNC_PRESTART_WORKER);
-        }
-    }
+    }
+
+    if (!fIsMaster)
+        if (!ASMAtomicCmpXchgU32(&pOtherSync->uSyncVar, GIP_TSC_DELTA_SYNC2_START, GIP_TSC_DELTA_SYNC2_PRESTART_WAIT)) /* race #1 */
+            return supdrvMeasureTscDeltaCallbackAbortSyncSetup(pArgs, &MySync, fIsMaster, false /*fTimeout*/);
 
     /*
@@ -3208 +3221 @@
     for (iTry = 0; iTry < 12; iTry++)
     {
+        if (ASMAtomicReadU32(&MySync.uSyncVar) != GIP_TSC_DELTA_SYNC2_START)
+            break;
+
         /*
          * Do the measurements.
          */
 #ifdef GIP_TSC_DELTA_METHOD_1
-        supdrvTscDeltaMethod1Loop(pArgs, pSync, fIsMaster, iTry);
+        supdrvTscDeltaMethod1Loop(pArgs, pSync1, &MySync, pOtherSync, fIsMaster, iTry);
 #elif defined(GIP_TSC_DELTA_METHOD_2)
-        supdrvTscDeltaMethod2Loop(pArgs, pSync, fIsMaster, iTry);
+        supdrvTscDeltaMethod2Loop(pArgs, pSync1, &MySync, pOtherSync, fIsMaster, iTry);
 #else
 # error "huh??"
 #endif
+        if (ASMAtomicReadU32(&MySync.uSyncVar) != GIP_TSC_DELTA_SYNC2_START)
+            break;
 
         /*
@@ -3237 +3255 @@
         }
     }
-}
-
-
-/**
- * Clears TSC delta related variables.
- *
- * Clears all TSC samples as well as the delta synchronization variable on the
- * all the per-CPU structs.  Optionally also clears the per-cpu deltas too.
- *
- * @param   pDevExt         Pointer to the device instance data.
- * @param   fClearDeltas    Whether the deltas are also to be cleared.
- */
-DECLINLINE(void) supdrvClearTscSamples(PSUPDRVDEVEXT pDevExt, bool fClearDeltas)
-{
-    unsigned iCpu;
-    PSUPGLOBALINFOPAGE pGip = pDevExt->pGip;
-    for (iCpu = 0; iCpu < pGip->cCpus; iCpu++)
-    {
-        PSUPGIPCPU pGipCpu = &pGip->aCPUs[iCpu];
-        ASMAtomicWriteU64(&pGipCpu->u64TSCSample, GIP_TSC_DELTA_RSVD);
-        if (fClearDeltas)
-            ASMAtomicWriteS64(&pGipCpu->i64TSCDelta, INT64_MAX);
-    }
-    ASMAtomicWriteU32(&pDevExt->pTscDeltaSync->u, GIP_TSC_DELTA_SYNC_STOP);
+
+    /*
+     * End the synchroniziation dance.  We tell the other that we're done,
+     * then wait for the same kind of reply.
+     */
+    ASMAtomicWriteU32(&pOtherSync->uSyncVar, GIP_TSC_DELTA_SYNC2_FINAL);
+    ASMAtomicWriteNullPtr(ppMySync);
+    iTry = 0;
+    while (ASMAtomicReadU32(&MySync.uSyncVar) != GIP_TSC_DELTA_SYNC2_FINAL)
+    {
+        iTry++;
+        if (   iTry == 0
+            && !RTMpIsCpuOnline(fIsMaster ? pGipCpuWorker->idCpu : pGipCpuWorker->idCpu))
+            break; /* this really shouldn't happen. */
+#if defined(DEBUG_bird) && defined(RT_OS_WINDOWS)
+if (iTry == 0) __debugbreak();
+#endif
+        ASMNopPause();
+    }
+
+    return 0;
+}
+
+/**
+ * Callback used by supdrvMeasureInitialTscDeltas() to read the TSC on two CPUs
+ * and compute the delta between them.
+ *
+ * @param   idCpu       The CPU we are current scheduled on.
+ * @param   pvUser1     Pointer to a parameter package (SUPDRVGIPTSCDELTARGS).
+ * @param   pvUser2     Unused.
+ */
+static DECLCALLBACK(void) supdrvMeasureTscDeltaCallback(RTCPUID idCpu, void *pvUser1, void *pvUser2)
+{
+    supdrvMeasureTscDeltaCallbackUnwrapped(idCpu, (PSUPDRVGIPTSCDELTARGS)pvUser1);
 }
 
@@ -3348 +3376 @@
     if (RTCpuSetIsMemberByIndex(&pGip->OnlineCpuSet, pGipCpuWorker->iCpuSet))
     {
+        /** @todo we need to check that the master is online...
+         * The old supdrvMeasureTscDeltaCallback code would spin forever. */
         /*
          * Initialize data package for the RTMpOnAll callback.
@@ -3353 +3383 @@
         SUPDRVGIPTSCDELTARGS Args;
         RT_ZERO(Args);
-        Args.pWorker     = pGipCpuWorker;
-        Args.pMaster     = pGipCpuMaster;
-        Args.pDevExt     = pDevExt;
-        Args.pSyncMaster = NULL;
-        Args.pSyncWorker = NULL;
+        Args.pWorker      = pGipCpuWorker;
+        Args.pMaster      = pGipCpuMaster;
+        Args.pDevExt      = pDevExt;
+        Args.pSyncMaster  = NULL;
+        Args.pSyncWorker  = NULL;
+#if 0 /* later */
+        Args.cMaxTscTicks = ASMAtomicReadU64(&pGip->u64CpuHz) / 2048; /* 488 us */
+#else
+        Args.cMaxTscTicks = ASMAtomicReadU64(&pGip->u64CpuHz) / 1024; /* 976 us */
+#endif
+
 #ifdef GIP_TSC_DELTA_METHOD_1
         rc = supdrvTscDeltaMethod1Init(&Args);
@@ -3420 +3456 @@
 
 /**
+ * Clears TSC delta related variables.
+ *
+ * Clears all TSC samples as well as the delta synchronization variable on the
+ * all the per-CPU structs.  Optionally also clears the per-cpu deltas too.
+ *
+ * @param   pDevExt         Pointer to the device instance data.
+ * @param   fClearDeltas    Whether the deltas are also to be cleared.
+ */
+static void supdrvClearTscSamples(PSUPDRVDEVEXT pDevExt, bool fClearDeltas)
+{
+    unsigned iCpu;
+    PSUPGLOBALINFOPAGE pGip = pDevExt->pGip;
+    for (iCpu = 0; iCpu < pGip->cCpus; iCpu++)
+    {
+        PSUPGIPCPU pGipCpu = &pGip->aCPUs[iCpu];
+        ASMAtomicWriteU64(&pGipCpu->u64TSCSample, GIP_TSC_DELTA_RSVD);
+        if (fClearDeltas)
+            ASMAtomicWriteS64(&pGipCpu->i64TSCDelta, INT64_MAX);
+    }
+    ASMAtomicWriteU32(&pDevExt->pTscDeltaSync->u, GIP_TSC_DELTA_SYNC_STOP);
+}
+
+
+/**
  * Performs the initial measurements of the TSC deltas between CPUs.
  *
@@ -3944 +4004 @@
         cTries = 256;
 
-    if (cMsWaitRetry > 1000)
+    if (cMsWaitRetry == 0)
+        cMsWaitRetry = 2;
+    else if (cMsWaitRetry > 1000)
         cMsWaitRetry = 1000;
 
@@ -4045 +4107 @@
         cTries--;
 
-        if (cMsWaitRetry)
-        {
-            rc = RTThreadSleep(cMsWaitRetry);
-            if (rc == VERR_INTERRUPTED)
-                break;
-        }
+        /* Always delay between retries (be nice to the rest of the system
+           and avoid the BSOD hounds). */
+        rc = RTThreadSleep(cMsWaitRetry);
+        if (rc == VERR_INTERRUPTED)
+            break;
     }
 
@@ -4172 +4233 @@
                 rc = supdrvMeasureTscDeltaOne(pDevExt, iGipCpu);
                 Assert(pGip->aCPUs[iGipCpu].i64TSCDelta != INT64_MAX || RT_FAILURE_NP(rc));
+                /** @todo should probably delay on failure... dpc watchdogs   */
             }
             else