Changeset 52725 in vbox for trunk/src/VBox/HostDrivers/Support

Timestamp:

Sep 12, 2014 2:03:14 PM (10 years ago)

Author:

vboxsync

Message:

HostDrivers/Support: Readjust TSC deltas if the master goes offline, and other code refactoring in preparation of recomputing deltas lazily.

File:

• trunk/src/VBox/HostDrivers/Support/SUPDrv.c (modified) (17 diffs)

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

@@ -167 +167 @@
                                                   RTCPUID idCpu, uint8_t idApic, uint64_t iTick);
 static void                 supdrvGipInitCpu(PSUPGLOBALINFOPAGE pGip, PSUPGIPCPU pCpu, uint64_t u64NanoTS);
-static int                  supdrvMeasureTscDeltas(PSUPDRVDEVEXT pDevExt, PSUPGLOBALINFOPAGE pGip, uint32_t *pidxMaster);
+static int                  supdrvMeasureTscDeltas(PSUPDRVDEVEXT pDevExt, uint32_t *pidxMaster);
+static int                  supdrvMeasureTscDeltaOne(PSUPDRVDEVEXT pDevExt, uint32_t idxWorker);
 static int                  supdrvIOCtl_ResumeSuspendedKbds(void);
 
@@ -5644 +5645 @@
             do
             {
-                rc = supdrvMeasureTscDeltas(pDevExt, pGip, NULL /* pidxMaster */);
+                rc = supdrvMeasureTscDeltas(pDevExt, NULL /* pidxMaster */);
                 if (rc == VERR_TRY_AGAIN)
                 {
@@ -5655 +5656 @@
             if (RT_SUCCESS(rc))
             {
-#if 0
-                unsigned iCpu;
-                SUPR0Printf("cTries=%u\n", cTries);
-                for (iCpu = 0; iCpu < pGip->cCpus; iCpu++)
-                    SUPR0Printf("Cpu[%3u].delta=%ld\n", iCpu, pGip->aCPUs[iCpu].i64TSCDelta);
-#endif
-
                 /*
                  * Create the timer.
@@ -5938 +5932 @@
     }
 
+    /* Reset the TSC delta, we will recalculate it lazily. */
+    ASMAtomicWriteS64(&pGip->aCPUs[i].i64TSCDelta, INT64_MAX);
+
     /* commit it */
     ASMAtomicWriteSize(&pGip->aCPUs[i].enmState, SUPGIPCPUSTATE_OFFLINE);
@@ -5980 +5977 @@
                 supdrvGipMpEventOffline(pDevExt, idCpu);
                 break;
-
         }
     }
@@ -5997 +5993 @@
             bool        fIgnored;
             unsigned    i;
+            int64_t     iTSCDelta;
+            uint32_t    idxNewGipMaster;
             RTCPUID     idNewGipMaster = NIL_RTCPUID;
             RTCPUSET    OnlineCpus;
@@ -6004 +6002 @@
             {
                 RTCPUID idCurCpu = RTMpCpuIdFromSetIndex(i);
-                if (    RTCpuSetIsMember(&OnlineCpus, idCurCpu)
-                    &&  idCurCpu != idGipMaster)
+                if (   RTCpuSetIsMember(&OnlineCpus, idCurCpu)
+                    && idCurCpu != idGipMaster)
                 {
                     idNewGipMaster = idCurCpu;
@@ -6015 +6013 @@
             ASMAtomicCmpXchgSize(&pDevExt->idGipMaster, idNewGipMaster, idGipMaster, fIgnored);
             NOREF(fIgnored);
+
+            /*
+             * Adjust all the TSC deltas against the new GIP master.
+             */
+            if (pGip)
+            {
+                idxNewGipMaster = supdrvGipCpuIndexFromCpuId(pGip, idNewGipMaster);
+                iTSCDelta       = pGip->aCPUs[idxNewGipMaster].i64TSCDelta;
+                Assert(iTSCDelta != UINT64_MAX);
+                for (i = 0; i < pGip->cCpus; i++)
+                {
+                    PSUPGIPCPU pGipCpu      = &pGip->aCPUs[i];
+                    int64_t    iWorkerDelta = pGipCpu->i64TSCDelta;
+                    if (iWorkerDelta != INT64_MAX)
+                        iWorkerDelta -= iTSCDelta;
+                    ASMAtomicWriteS64(&pGipCpu->i64TSCDelta, iWorkerDelta);
+                }
+                Assert(pGip->aCPUs[idxNewGipMaster].i64TSCDelta == 0);
+            }
         }
     }
@@ -6043 +6060 @@
  *     earlier.
  */
-static DECLCALLBACK(void) supdrvDetermineTscDeltaCallback(RTCPUID idCpu, void *pvUser1, void *pvUser2)
+static DECLCALLBACK(void) supdrvMeasureTscDeltaCallback(RTCPUID idCpu, void *pvUser1, void *pvUser2)
 {
     PSUPGLOBALINFOPAGE pGip      = (PSUPGLOBALINFOPAGE)pvUser1;
@@ -6053 +6070 @@
     PSUPGIPCPU         pGipCpuWorker = &pGip->aCPUs[idxWorker];
     uint64_t           uMinCmpReadTime = UINT64_MAX;
-    int                cTriesLeft = 8;
+    int                cTriesLeft = 12;
 
     if (   idCpu != idMaster
@@ -6111 +6128 @@
         for (i = 0; i < GIP_TSC_DELTA_LOOPS; i++)
         {
+            ASMCompilerBarrier();
             if (idCpu == idMaster)
             {
@@ -6226 +6244 @@
 
 /**
+ * Measures the TSC delta between the master GIP CPU and one specified worker
+ * CPU.
+ *
+ * @returns VBox status code.
+ * @param   pDevExt         Pointer to the device instance data.
+ * @param   idxWorker       The index of the worker CPU from the GIP's array of
+ *                          CPUs.
+ *
+ * @remarks This can be called with preemption disabled!
+ */
+static int supdrvMeasureTscDeltaOne(PSUPDRVDEVEXT pDevExt, uint32_t idxWorker)
+{
+    PSUPGLOBALINFOPAGE pGip  = pDevExt->pGip;
+    RTCPUID    idMaster      = pDevExt->idGipMaster;
+    uint32_t   idxMaster     = supdrvGipCpuIndexFromCpuId(pGip, idMaster);
+    PSUPGIPCPU pGipCpuWorker = &pGip->aCPUs[idxWorker];
+    int        rc            = VERR_CPU_OFFLINE;
+
+    if (idxWorker == idxMaster)
+    {
+        ASMAtomicWriteS64(&pGipCpuWorker->i64TSCDelta, 0);
+        return VINF_SUCCESS;
+    }
+
+    /* Set the master TSC as the initiator. */
+    while (ASMAtomicCmpXchgU32(&g_idTscDeltaInitiator, idMaster, NIL_RTCPUID) == false)
+        ASMNopPause();
+
+    if (RTCpuSetIsMember(&pGip->OnlineCpuSet, pGipCpuWorker->idCpu))
+    {
+        /* Fire TSC-read workers on all CPUs but only synchronize between master and one worker to ease memory contention. */
+        ASMAtomicWriteU32(&g_pTscDeltaSync->u, GIP_TSC_DELTA_SYNC_STOP);
+        rc = RTMpOnAll(supdrvMeasureTscDeltaCallback, pGip, &pGipCpuWorker->idCpu);
+        if (RT_SUCCESS(rc))
+        {
+            if (RT_UNLIKELY(pGipCpuWorker->i64TSCDelta == INT64_MAX))
+                rc = VERR_UNRESOLVED_ERROR;
+        }
+    }
+
+    ASMAtomicWriteU32(&g_idTscDeltaInitiator, NIL_RTCPUID);
+    return rc;
+}
+
+
+/**
  * Measures the TSC deltas between CPUs.
  *
  * @param   pDevExt     Pointer to the device instance data.
- * @param   pGip        Pointer to the GIP.
  * @param   pidxMaster  Where to store the index of the chosen master TSC if we
  *                      managed to determine the TSC deltas successfully.
@@ -6239 +6302 @@
  *          supdrvGipInitOnCpu().
  */
-static int supdrvMeasureTscDeltas(PSUPDRVDEVEXT pDevExt, PSUPGLOBALINFOPAGE pGip, uint32_t *pidxMaster)
+static int supdrvMeasureTscDeltas(PSUPDRVDEVEXT pDevExt, uint32_t *pidxMaster)
 {
     PSUPGIPCPU pGipCpuMaster;
     unsigned   iCpu;
+    PSUPGLOBALINFOPAGE pGip   = pDevExt->pGip;
+    uint32_t   idxMaster      = UINT32_MAX;
+    int        rc             = VINF_SUCCESS;
     uint32_t   cMpOnOffEvents = ASMAtomicReadU32(&g_cMpOnOffEvents);
     uint32_t   cOnlineCpus    = pGip->cOnlineCpus;
 
-    /* Pick the first CPU which is online as the master TSC. */
-    uint32_t idxMaster = UINT32_MAX;
+    /*
+     * Pick the first CPU online as the master TSC and make it the new GIP master.
+     *                                                                                                                                        .
+     * Technically we can simply use "idGipMaster" but doing this gives us master as CPU 0                                                    .
+     * in most cases making it nicer/easier for comparisons. It is safe to update the GIP
+     * master as this point since the sync/async timer isn't created yet.
+     */
     supdrvClearTscSamples(pGip, true /* fClearDeltas */);
     for (iCpu = 0; iCpu < pGip->cCpus; iCpu++)
@@ -6259 +6330 @@
         }
     }
+    AssertReturn(idxMaster != UINT32_MAX, VERR_CPU_NOT_FOUND);
+    pGipCpuMaster = &pGip->aCPUs[idxMaster];
+    ASMAtomicWriteSize(&pDevExt->idGipMaster, pGipCpuMaster->idCpu);
+
     AssertReturn(cOnlineCpus > 0, VERR_INTERNAL_ERROR_5);
-    AssertReturn(idxMaster != UINT32_MAX, VERR_CPU_NOT_FOUND);
-
     if (pGip->cOnlineCpus <= 1)
     {
@@ -6269 +6342 @@
     }
 
-    /* Pick the master TSC as the initiator. */
-    pGipCpuMaster = &pGip->aCPUs[idxMaster];
-    ASMAtomicWriteU32(&g_idTscDeltaInitiator, pGipCpuMaster->idCpu);
-
     for (iCpu = 0; iCpu < pGip->cCpus; iCpu++)
     {
@@ -6279 +6348 @@
             && RTCpuSetIsMember(&pGip->OnlineCpuSet, pGipCpuWorker->idCpu))
         {
-            int rc;
-
-            /* Fire TSC-read workers on all CPUs but only synchronize between master and one worker to memory contention. */
-            ASMAtomicWriteU32(&g_pTscDeltaSync->u, GIP_TSC_DELTA_SYNC_STOP);
-            rc = RTMpOnAll(supdrvDetermineTscDeltaCallback, pGip, &pGipCpuWorker->idCpu);
+            rc = supdrvMeasureTscDeltaOne(pDevExt, iCpu);
             if (RT_FAILURE(rc))
             {
-                SUPR0Printf("supdrvMeasureTscDeltas: RTMpOnAll failed. rc=%d\n", rc);
-                return rc;
-            }
-
-            if (RT_UNLIKELY(pGipCpuWorker->i64TSCDelta == INT64_MAX))
-            {
-                SUPR0Printf("Failed to measure TSC deltas for CPU[%u] idCpu=%u\n", iCpu, pGipCpuWorker->idCpu);
-                return VERR_UNRESOLVED_ERROR;
+                SUPR0Printf("supdrvMeasureTscDeltaOne failed. rc=%d CPU[%u].idCpu=%u Master[%u].idCpu=%u\n", rc, iCpu,
+                            pGipCpuWorker->idCpu, idxMaster, pDevExt->idGipMaster, pGipCpuMaster->idCpu);
+                break;
             }
 
@@ -6299 +6359 @@
             {
                 SUPR0Printf("One or more CPUs transitioned between online & offline states. I are confused, retrying...\n");
-                return VERR_TRY_AGAIN;
-            }
-        }
-    }
-
-    ASMAtomicWriteU32(&g_idTscDeltaInitiator, NIL_RTCPUID);
-
-    if (RT_LIKELY(!pGipCpuMaster->i64TSCDelta))
-    {
-        if (pidxMaster)
-            *pidxMaster = idxMaster;
-        return VINF_SUCCESS;
-    }
-    return VERR_INTERNAL_ERROR_4;
+                rc = VERR_TRY_AGAIN;
+                break;
+            }
+        }
+    }
+
+    if (   RT_SUCCESS(rc)
+        && !pGipCpuMaster->i64TSCDelta
+        && pidxMaster)
+    {
+        *pidxMaster = idxMaster;
+    }
+    return rc;
 }