Changeset 212541 in webkit for trunk/Source/JavaScriptCore/heap/HeapTimer.cpp

Timestamp:

Feb 17, 2017, 1:13:58 AM (8 years ago)

Author:

[email protected]

Message:

[GLib] GCActivityCallback::scheduleTimer() keeps pushing dispatch into the future
​https://bugs.webkit.org/show_bug.cgi?id=168363

Reviewed by Carlos Garcia Campos.

Mimic the USE(CF) implementation of GCActivityCallback and HeapTimer by
scheduling the timer a decade into the future instead of completely
cancelling it. That way new dispatch times for GCActivityCallback can be
computed by simply deducting the difference in the new and previous
delay from the GSource's current dispatch time. Previously we handled an
extra 'paused' state (where m_delay was -1) and allowed for a delay of
an infinite value to be valid, complicating the next dispatch time
computation.

HeapTimer gains the static s_decade variable. The dispatch function in
heapTimerSourceFunctions only dispatches the callback, which now delays
the GSource by a decade. HeapTimer::scheduleTimer() simply schedules the
source to dispatch in the specified amount of time, and cancelTimer()
'cancels' the source by setting the dispatch time to a decade.

GCActivityCallback constructor initializes the delay to the s_decade
value and immediately sets the ready time for GSource a decade into the
future, avoiding the default -1 value as the ready time that would cause
problems in scheduleTimer(). scheduleTimer() doesn't special-case the
zero-delay value anymore, instead it just computes the difference
between the old and the new delay and rolls back the GSource's ready
time for that amount. cancelTimer() sets m_delay to the decade value and
delays the GSource for that same amount.

• heap/GCActivityCallback.cpp:

(JSC::GCActivityCallback::GCActivityCallback):
(JSC::GCActivityCallback::scheduleTimer):
(JSC::GCActivityCallback::cancelTimer):

• heap/GCActivityCallback.h:
• heap/HeapTimer.cpp:

(JSC::HeapTimer::HeapTimer):
(JSC::HeapTimer::scheduleTimer):
(JSC::HeapTimer::cancelTimer):

• heap/HeapTimer.h:

File:

• trunk/Source/JavaScriptCore/heap/HeapTimer.cpp (modified) (4 diffs)

trunk/Source/JavaScriptCore/heap/HeapTimer.cpp

@@ -109 +109 @@
 #elif USE(GLIB)
 
+const long HeapTimer::s_decade = 60 * 60 * 24 * 365 * 10;
+
 static GSourceFuncs heapTimerSourceFunctions = {
     nullptr, // prepare
     nullptr, // check
     // dispatch
-    [](GSource* source, GSourceFunc callback, gpointer userData) -> gboolean
+    [](GSource*, GSourceFunc callback, gpointer userData) -> gboolean
     {
-        if (g_source_get_ready_time(source) == -1)
-            return G_SOURCE_CONTINUE;
-        g_source_set_ready_time(source, -1);
         return callback(userData);
     },
@@ -132 +131 @@
     g_source_set_name(m_timer.get(), "[JavaScriptCore] HeapTimer");
     g_source_set_callback(m_timer.get(), [](gpointer userData) -> gboolean {
-        static_cast<HeapTimer*>(userData)->timerDidFire();
+        auto& heapTimer = *static_cast<HeapTimer*>(userData);
+        g_source_set_ready_time(heapTimer.m_timer.get(), g_get_monotonic_time() + HeapTimer::s_decade * G_USEC_PER_SEC);
+        heapTimer.timerDidFire();
         return G_SOURCE_CONTINUE;
     }, this, nullptr);
@@ -163 +164 @@
 void HeapTimer::scheduleTimer(double intervalInSeconds)
 {
-    auto delayDuration = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::duration<double>(intervalInSeconds));
-    gint64 currentTime = g_get_monotonic_time();
-    gint64 targetTime = currentTime + std::min<gint64>(G_MAXINT64 - currentTime, delayDuration.count());
-    ASSERT(targetTime >= currentTime);
-    g_source_set_ready_time(m_timer.get(), targetTime);
+    g_source_set_ready_time(m_timer.get(), g_get_monotonic_time() + intervalInSeconds * G_USEC_PER_SEC);
     m_isScheduled = true;
 }
@@ -173 +170 @@
 void HeapTimer::cancelTimer()
 {
-    g_source_set_ready_time(m_timer.get(), -1);
+    g_source_set_ready_time(m_timer.get(), g_get_monotonic_time() + s_decade * G_USEC_PER_SEC);
     m_isScheduled = false;
 }