Changeset 9466 in vbox for trunk/src/VBox/Runtime/r0drv/linux

Timestamp:

Jun 6, 2008 11:44:27 AM (17 years ago)

Author:

vboxsync

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

31723

Message:

Fixes and optimizations. The HRTIMER code is still unusable, though. :-/

File:

• trunk/src/VBox/Runtime/r0drv/linux/timer-r0drv-linux.c (modified) (7 diffs)

trunk/src/VBox/Runtime/r0drv/linux/timer-r0drv-linux.c

@@ -108 +108 @@
     /** Pointer to the parent timer. */
     PRTTIMER                pParent;
+#ifndef RT_USE_LINUX_HRTIMER
+    /** The u64NextTS in jiffies. */
+    unsigned long           ulNextJiffies;
+#endif
     /** The current sub-timer state. */
     RTTIMERLNXSTATE volatile enmState;
@@ -146 +150 @@
     /** The timer interval. 0 if one-shot. */
     uint64_t                u64NanoInterval;
+#ifndef RT_USE_LINUX_HRTIMER
+    /** This is set to the number of jiffies between ticks if the interval is
+     * an exact number of jiffies. */
+    unsigned long           cJiffies;
+#endif
     /** Sub-timers.
      * Normally there is just one, but for RTTIMER_FLAGS_CPU_ALL this will contain
@@ -195 +204 @@
 
 
-#ifndef RT_USE_LINUX_HRTIMER
+#ifdef RT_USE_LINUX_HRTIMER
+/**
+ * Converts a nano second time stamp to ktime_t.
+ *
+ * ASSUMES RTTimeNanoTS() is implemented using ktime_get_ts().
+ *
+ * @returns ktime_t.
+ * @param   cNanoSecs   Nanoseconds.
+ */
+DECLINLINE(ktime_t) rtTimerLnxNanoToKt(uint64_t cNanoSecs)
+{
+    /* With some luck the compiler optimizes the division out of this... (Bet it doesn't.) */
+    return ktime_set(cNanoSecs / 1000000000, cNanoSecs % 1000000000);
+}
+
+/**
+ * Converts ktime_t to a nano second time stamp.
+ *
+ * ASSUMES RTTimeNanoTS() is implemented using ktime_get_ts().
+ *
+ * @returns nano second time stamp.
+ * @param   Kt          ktime_t.
+ */
+DECLINLINE(uint64_t) rtTimerLnxKtToNano(ktime_t Kt)
+{
+    return ktime_to_ns(Kt);
+}
+
+#else /* ! RT_USE_LINUX_HRTIMER */
+
 /**
  * Converts a nano second interval to jiffies.
@@ -234 +272 @@
 
 #ifdef RT_USE_LINUX_HRTIMER
-    {
-        /* ASSUMES RTTimeNanoTS() is implemented using ktime_get_ts(). */
-        struct timespec Ts;
-        ktime_t Kt;
-        Ts.tv_sec  = u64NextTS / 1000000000;
-        Ts.tv_nsec = u64NextTS % 1000000000;
-        Kt = timespec_to_ktime(Ts);
-        hrtimer_start(&pSubTimer->LnxTimer, Kt, HRTIMER_MODE_ABS);
-    }
+    hrtimer_start(&pSubTimer->LnxTimer, rtTimerLnxNanoToKt(u64NextTS), HRTIMER_MODE_ABS);
 #else
     {
         unsigned long cJiffies = !u64First ? 0 : rtTimerLnxNanoToJiffies(u64First);
-        mod_timer(&pSubTimer->LnxTimer, jiffies + cJiffies);
+        pSubTimer->ulNextJiffies = jiffies + cJiffies;
+        mod_timer(&pSubTimer->LnxTimer, pSubTimer->ulNextJiffies);
     }
 #endif
@@ -341 +372 @@
         const uint64_t u64NanoTS = RTTimeNanoTS();
         const uint64_t iTick = ++pSubTimer->iTick;
-#ifdef RT_USE_LINUX_HRTIMER
-        if (iTick == 1)
-            pSubTimer->u64StartTS = u64NanoTS;
-#endif
-        pSubTimer->u64NextTS = pSubTimer->u64StartTS
-                             + iTick * pTimer->u64NanoInterval;
-        if (pSubTimer->u64NextTS < u64NanoTS)
-            pSubTimer->u64NextTS = u64NanoTS + RTTimerGetSystemGranularity() / 2;
-
-#ifdef RT_USE_LINUX_HRTIMER
+
+        if (RT_UNLIKELY(iTick == 1))
         {
-            /* ASSUMES RTTimeNanoTS() is implemented using ktime_get_ts(). */
-            struct timespec Ts;
-            Ts.tv_sec  = pSubTimer->u64NextTS / 1000000000;
-            Ts.tv_nsec = pSubTimer->u64NextTS % 1000000000;
-            pSubTimer->LnxTimer.expires = timespec_to_ktime(Ts);
-            rc = HRTIMER_RESTART;
+#ifdef RT_USE_LINUX_HRTIMER
+            pSubTimer->u64StartTS = pSubTimer->u64NextTS = u64NanoTS;//rtTimerLnxKtToNano(pSubTimer->LnxTimer.base->softirq_time);
+#else
+            pSubTimer->u64StartTS = pSubTimer->u64NextTS = u64NanoTS;
+            pSubTimer->ulNextJiffies = jiffies;
+#endif
         }
-#else
+
+        pSubTimer->u64NextTS += pTimer->u64NanoInterval;
+
+#ifdef RT_USE_LINUX_HRTIMER
+        while (pSubTimer->u64NextTS < u64NanoTS)
+            pSubTimer->u64NextTS += pTimer->u64NanoInterval;
+
+        pSubTimer->LnxTimer.expires = rtTimerLnxNanoToKt(pSubTimer->u64NextTS);
+        rc = HRTIMER_RESTART;
+#else
+        if (pTimer->cJiffies)
         {
-            uint64_t offDelta = pSubTimer->u64NextTS - u64NanoTS;
-            unsigned long cJiffies = rtTimerLnxNanoToJiffies(offDelta);
-            mod_timer(&pSubTimer->LnxTimer, jiffies + cJiffies);
+            pSubTimer->ulNextJiffies += pTimer->cJiffies;
+            while (pSubTimer->ulNextJiffies < jiffies)
+            {
+                pSubTimer->ulNextJiffies += pTimer->cJiffies;
+                pSubTimer->u64NextTS += pTimer->u64NanoInterval;
+            }
         }
+        else
+        {
+            while (pSubTimer->u64NextTS < u64NanoTS)
+                pSubTimer->u64NextTS += pTimer->u64NanoInterval;
+            pSubTimer->ulNextJiffies = jiffies + rtTimerLnxNanoToJiffies(pSubTimer->u64NextTS - u64NanoTS);
+        }
+
+        mod_timer(&pSubTimer->LnxTimer, pSubTimer->ulNextJiffies);
 #endif
 
@@ -826 +870 @@
     pTimer->pvUser = pvUser;
     pTimer->u64NanoInterval = u64NanoInterval;
+#ifndef RT_USE_LINUX_HRTIMER
+    pTimer->cJiffies = u64NanoInterval / RTTimerGetSystemGranularity();
+    if (pTimer->cJiffies * RTTimerGetSystemGranularity() != u64NanoInterval)
+        pTimer->cJiffies = 0;
+#endif
 
     for (iCpu = 0; iCpu < cCpus; iCpu++)
@@ -875 +924 @@
 {
 #ifdef RT_USE_LINUX_HRTIMER
-    /** @todo later... */
+    struct timespec Ts;
+    int rc = hrtimer_get_res(CLOCK_MONOTONIC, &Ts);
+    if (!rc)
+    {
+        Assert(!Ts.tv_sec);
+        return Ts.tv_nsec;
+    }
     return 1000000000 / HZ; /* ns */
 #else