Changeset 261999 in webkit

Timestamp:

May 21, 2020 8:35:21 AM (4 years ago)

Author:

Simon Fraser

Message:

[macOS] Scrolling synchronization part 2: Have the scrolling thread detect when the main thread is slow to respond to start a rendering update
​https://bugs.webkit.org/show_bug.cgi?id=212175

Reviewed by Tim Horton.

The scrolling thread now detects when a main thread rendering update is taking too long, going into
desynchronized mode when that happens.

However, there's another state that needs to be handled, which is the main thread being busy and
taking too long to start the rendering update. The scrolling thread gets a "displayDidRefresh" ping
and expects that the main thread will get the same ping, and use it to start the rendering update,
but a busy main thread won't respond to this ping promptly.

Detect this with a short-duration (1ms) timer that fires on the scrolling thread; if the timer fires
we go into desynchronized mode until the next update. The timer is canceled if the scrolling thread
receives the willStartRenderingUpdate().

• page/scrolling/ThreadedScrollingTree.cpp:

(WebCore::ThreadedScrollingTree::waitForRenderingUpdateCompletionOrTimeout):
(WebCore::ThreadedScrollingTree::scheduleDelayedRenderingUpdateDetectionTimer):
(WebCore::ThreadedScrollingTree::delayedRenderingUpdateDetectionTimerFired):
(WebCore::ThreadedScrollingTree::displayDidRefreshOnScrollingThread):

• page/scrolling/ThreadedScrollingTree.h:

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• page/scrolling/ThreadedScrollingTree.cpp (modified) (3 diffs)
• page/scrolling/ThreadedScrollingTree.h (modified) (3 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2020-05-21  Simon Fraser  <simon.fraser@apple.com>
+
+        [macOS] Scrolling synchronization part 2: Have the scrolling thread detect when the main thread is slow to respond to start a rendering update
+        https://bugs.webkit.org/show_bug.cgi?id=212175
+
+        Reviewed by Tim Horton.
+
+        The scrolling thread now detects when a main thread rendering update is taking too long, going into
+        desynchronized mode when that happens.
+
+        However, there's another state that needs to be handled, which is the main thread being busy and
+        taking too long to start the rendering update. The scrolling thread gets a "displayDidRefresh" ping
+        and expects that the main thread will get the same ping, and use it to start the rendering update,
+        but a busy main thread won't respond to this ping promptly.
+
+        Detect this with a short-duration (1ms) timer that fires on the scrolling thread; if the timer fires
+        we go into desynchronized mode until the next update. The timer is canceled if the scrolling thread
+        receives the willStartRenderingUpdate(). 
+
+        * page/scrolling/ThreadedScrollingTree.cpp:
+        (WebCore::ThreadedScrollingTree::waitForRenderingUpdateCompletionOrTimeout):
+        (WebCore::ThreadedScrollingTree::scheduleDelayedRenderingUpdateDetectionTimer):
+        (WebCore::ThreadedScrollingTree::delayedRenderingUpdateDetectionTimerFired):
+        (WebCore::ThreadedScrollingTree::displayDidRefreshOnScrollingThread):
+        * page/scrolling/ThreadedScrollingTree.h:
+
 2020-05-21  Sergio Villar Senin  <svillar@igalia.com>
 

trunk/Source/WebCore/page/scrolling/ThreadedScrollingTree.cpp

@@ -241 +241 @@
     ASSERT(m_treeMutex.isLocked());
 
+    if (m_delayedRenderingUpdateDetectionTimer)
+        m_delayedRenderingUpdateDetectionTimer->stop();
+
     auto startTime = MonotonicTime::now();
     auto timeoutTime = startTime + maxAllowableRenderingUpdateDurationForSynchronization();
@@ -271 +274 @@
 }
 
+void ThreadedScrollingTree::scheduleDelayedRenderingUpdateDetectionTimer(Seconds delay)
+{
+    ASSERT(ScrollingThread::isCurrentThread());
+    ASSERT(m_treeMutex.isLocked());
+
+    if (!m_delayedRenderingUpdateDetectionTimer)
+        m_delayedRenderingUpdateDetectionTimer = makeUnique<RunLoop::Timer<ThreadedScrollingTree>>(RunLoop::current(), this, &ThreadedScrollingTree::delayedRenderingUpdateDetectionTimerFired);
+
+    m_delayedRenderingUpdateDetectionTimer->startOneShot(delay);
+}
+
+void ThreadedScrollingTree::delayedRenderingUpdateDetectionTimerFired()
+{
+    ASSERT(ScrollingThread::isCurrentThread());
+
+    LockHolder treeLocker(m_treeMutex);
+    applyLayerPositionsInternal();
+    m_state = SynchronizationState::Desynchronized;
+}
+
 void ThreadedScrollingTree::displayDidRefreshOnScrollingThread()
 {
@@ -284 +307 @@
     case SynchronizationState::Idle: {
         m_state = SynchronizationState::WaitingForRenderingUpdate;
+        constexpr auto maxStartRenderingUpdateDelay = 1_ms;
+        scheduleDelayedRenderingUpdateDetectionTimer(maxStartRenderingUpdateDelay);
         break;
     }

trunk/Source/WebCore/page/scrolling/ThreadedScrollingTree.h

@@ -32 +32 @@
 #include <wtf/Condition.h>
 #include <wtf/RefPtr.h>
+#include <wtf/RunLoop.h>
 
 namespace WebCore {
@@ -86 +87 @@
     void displayDidRefreshOnScrollingThread();
     void waitForRenderingUpdateCompletionOrTimeout();
-    
+
+    void scheduleDelayedRenderingUpdateDetectionTimer(Seconds);
+    void delayedRenderingUpdateDetectionTimerFired();
+
     Seconds maxAllowableRenderingUpdateDurationForSynchronization();
 
@@ -100 +104 @@
     SynchronizationState m_state { SynchronizationState::Idle };
     Condition m_stateCondition;
+
+    // Dynamically allocated because it has to use the ScrollingThread's runloop.
+    std::unique_ptr<RunLoop::Timer<ThreadedScrollingTree>> m_delayedRenderingUpdateDetectionTimer;
 };