Changeset 40888 in webkit for trunk/JavaScriptCore/wtf/MainThread.cpp

Timestamp:

Feb 11, 2009, 11:58:36 PM (16 years ago)

Author:

[email protected]

Message:

2009-02-11 Dmitry Titov <​[email protected]>

Reviewed by Alexey Proskuryakov.

​https://bugs.webkit.org/show_bug.cgi?id=23705
Fix the UI freeze caused by Worker generating a flood of messages.
Measure time we spend in executing posted work items. If too much time is spent
without returning to the run loop, exit and reschedule.

• wtf/MainThread.h: Added initializeMainThreadPlatform() to initialize low-level mechanism for posting work items from thread to thread. This removes #ifdefs for WIN and CHROMIUM from platform-independent code.

• wtf/MainThread.cpp: (WTF::initializeMainThread): (WTF::dispatchFunctionsFromMainThread): Instead of dispatching all work items in the queue, dispatch them one by one and measure elapsed time. After a threshold, reschedule and quit.

(WTF::callOnMainThread):
(WTF::callOnMainThreadAndWait):
Only schedule dispatch if the queue was empty - to avoid many posted messages in the run loop queue.

• wtf/mac/MainThreadMac.mm: (WTF::scheduleDispatchFunctionsOnMainThread): Use static instance of the mainThreadCaller instead of allocating and releasing it each time. (WTF::initializeMainThreadPlatform):
• wtf/gtk/MainThreadChromium.cpp: (WTF::initializeMainThreadPlatform):
• wtf/gtk/MainThreadGtk.cpp: (WTF::initializeMainThreadPlatform):
• wtf/qt/MainThreadQt.cpp: (WTF::initializeMainThreadPlatform):
• wtf/win/MainThreadWin.cpp: (WTF::initializeMainThreadPlatform):
• wtf/wx/MainThreadWx.cpp: (WTF::initializeMainThreadPlatform):

File:

• trunk/JavaScriptCore/wtf/MainThread.cpp (modified) (6 diffs)

trunk/JavaScriptCore/wtf/MainThread.cpp

@@ -30 +30 @@
 #include "MainThread.h"
 
+#include "CurrentTime.h"
+#include "Deque.h"
 #include "StdLibExtras.h"
 #include "Threading.h"
-#include "Vector.h"
 
 namespace WTF {
@@ -49 +50 @@
 };
 
-typedef Vector<FunctionWithContext> FunctionQueue;
+typedef Deque<FunctionWithContext> FunctionQueue;
 
 static bool callbacksPaused; // This global variable is only accessed from main thread.
@@ -65 +66 @@
 }
 
-#if !PLATFORM(WIN) && !PLATFORM(CHROMIUM)
 void initializeMainThread()
 {
     mainThreadFunctionQueueMutex();
+    initializeMainThreadPlatform();
 }
-#endif
+
+// 0.1 sec delays in UI is approximate threshold when they become noticeable. Have a limit that's half of that.
+static const double maxRunLoopSuspensionTime = 0.05;
 
 void dispatchFunctionsFromMainThread()
@@ -79 +82 @@
         return;
 
-    FunctionQueue queueCopy;
-    {
-        MutexLocker locker(mainThreadFunctionQueueMutex());
-        queueCopy.swap(functionQueue());
-    }
+    double startTime = currentTime();
 
-    for (unsigned i = 0; i < queueCopy.size(); ++i) {
-        FunctionWithContext& invocation = queueCopy[i];
+    FunctionWithContext invocation;
+    while (true) {
+        {
+            MutexLocker locker(mainThreadFunctionQueueMutex());
+            if (!functionQueue().size())
+                break;
+            invocation = functionQueue().first();
+            functionQueue().removeFirst();
+        }
+
         invocation.function(invocation.context);
         if (invocation.syncFlag)
             invocation.syncFlag->signal();
+        
+        // If we are running accumulated functions for too long so UI may become unresponsive, we need to
+        // yield so the user input can be processed. Otherwise user may not be able to even close the window.
+        // This code has effect only in case the scheduleDispatchFunctionsOnMainThread() is implemented in a way that
+        // allows input events to be processed before we are back here.
+        if (currentTime() - startTime > maxRunLoopSuspensionTime) {
+            scheduleDispatchFunctionsOnMainThread();
+            break;
+        }
     }
 }
@@ -96 +112 @@
 {
     ASSERT(function);
-
+    bool needToSchedule = false;
     {
         MutexLocker locker(mainThreadFunctionQueueMutex());
+        needToSchedule = functionQueue().size() == 0;
         functionQueue().append(FunctionWithContext(function, context));
     }
-
-    scheduleDispatchFunctionsOnMainThread();
+    if (needToSchedule)
+        scheduleDispatchFunctionsOnMainThread();
 }
 
@@ -116 +133 @@
     ThreadCondition syncFlag;
     Mutex conditionMutex;
-
+    bool needToSchedule = false;
     {
         MutexLocker locker(mainThreadFunctionQueueMutex());
+        needToSchedule = functionQueue().size() == 0;
         functionQueue().append(FunctionWithContext(function, context, &syncFlag));
         conditionMutex.lock();
     }
 
-    scheduleDispatchFunctionsOnMainThread();
+    if (needToSchedule)
+        scheduleDispatchFunctionsOnMainThread();
     syncFlag.wait(conditionMutex);
 }