Changeset 175

Timestamp:

Sep 9, 2009, 10:02:31 PM (16 years ago)

Author:

Dmitry A. Kuminov

Message:

corelib: Improved timers: don't block other threads by constantly posting close-to-zero timers to the message queue in cases when the target thread isn't fast enough to process them. This fixes spontaneous hangs during the termination of applications that use many timers and run other threads they wait for at exit.

File:

• trunk/src/corelib/kernel/qeventdispatcher_pm.cpp (modified) (16 diffs)

trunk/src/corelib/kernel/qeventdispatcher_pm.cpp

@@ -235 +235 @@
 }
 
+inline bool operator>=(const timeval &t1, const timeval &t2)
+{
+    return !operator<(t1, t2);
+}
+
 inline timeval &operator+=(timeval &t1, const timeval &t2)
 {
@@ -286 +291 @@
     static bool removeTimers(QObject *object);
     static QList<QPair<int, int> > knownTimers(QObject *object);
-    static QObject *getTimerObject(int timerId);
+    static QObject *getTimerObject(int timerId, bool reset);
 
     static void attachThread();
@@ -340 +345 @@
         QObject *obj;     // - object to receive event
         HWND hwnd;        // - where to post the timer message
+        bool posted;      // - true if a message has been posted
     };
 
@@ -347 +353 @@
     typedef QMap<timeval, TimerInfo*> TimevalMap;
     TimevalMap timersByTimeout;
+    bool allTimersPosted;
 
     timeval currentTime;
@@ -463 +470 @@
     t->obj = object;
     t->hwnd = hwnd;
+    t->posted = false;
 
     instance->timers.insert(t->id, t);
@@ -546 +554 @@
     that owns the timer (creates/registers/unregisters it).
 
+    If @a reset is true, the method also resets the 'posted' flag so that a
+    message for it may be posted again by the select thread.
+
     May return 0 if the timer is stopped/deleted after WM_U_SEM_TIMER was issued
     for it but before this message gets processed by the owning thread.
 */
 // static
-QObject *QSelectThread::getTimerObject(int timerId)
+QObject *QSelectThread::getTimerObject(int timerId, bool reset)
 {
     QMutexLocker locker(&mutex);
@@ -556 +567 @@
 
     TimerInfo *t = instance->timers.value(timerId);
-    if (t)
+    if (t) {
+        if (reset) {
+            t->posted = false;
+            if (instance->allTimersPosted) {
+                // the select thread's been sleeping forever; wake it up -- we
+                // now have at least one timer that can be posted again
+                instance->allTimersPosted = false;
+                instance->cancelSelectOrIdle();
+            } else {
+                // also wake it up if this timer was skipped when choosing the
+                // shortest wait interval so that a longer once could be chosen
+                bool haveNonPosted = false;
+                for (TimevalMap::const_iterator it = instance->timersByTimeout.begin();
+                     it != instance->timersByTimeout.end() && !haveNonPosted &&
+                     it.value() != t;
+                     ++it) {
+                    if (!it.value()->posted)
+                        haveNonPosted = true;
+                }
+                if (!haveNonPosted)
+                    instance->cancelSelectOrIdle();
+            }
+        }
         return t->obj;
+    }
 
     return 0;
@@ -656 +690 @@
 }
 
-QSelectThread::QSelectThread() : finish(false), refcnt(0), cancelWait(false)
+QSelectThread::QSelectThread()
+    : finish(false), refcnt(0), cancelWait(false), allTimersPosted(false)
 {
     // initialize socket stuff
@@ -771 +806 @@
             mutex.lock();
         } else {
-            ulong msecs = timeout ?
-                timeout->tv_sec * 1000 + timeout->tv_usec / 1000 : ULONG_MAX;
-            nsel = -1; // cause to avoid activateTimers() when cancelled
+            nsel = -1;
+            errno = EINTR;
             if (!cancelWait) {
+                long msecs = timeout ?
+                    timeout->tv_sec * 1000l + timeout->tv_usec / 1000l : LONG_MAX;
                 if (!cond.wait(&mutex, msecs))
                     nsel = 0; // indicate timeout
@@ -781 +817 @@
         }
 
-        if (nsel == 0) {
-            // timeout, check if there are expired timers
+        if (nsel == 0 || (nsel == -1 && errno == EINTR)) {
+            // interrupt or timeout; check if there are expired or processed
+            // timers
             activateTimers();
         }
@@ -892 +929 @@
 
 /*
-  Returns the time to wait for the next timer, or null if no timers
-  are waiting.
+  Returns the time to wait for the next timer, or false if no timers are
+  waiting.
 */
 bool QSelectThread::timerWait(timeval &tm)
@@ -902 +939 @@
         return false;
 
-    TimerInfo *t = timersByTimeout.begin().value();    // first waiting timer
+    // find first waiting timer with posted flag reset
+    TimevalMap::iterator it = timersByTimeout.begin();
+    while (it.value()->posted && it != timersByTimeout.end())
+        ++it;
+    if (it == timersByTimeout.end()) {
+        // all timers've been posted but not yet processed by the target window;
+        // set a flag to make sure the first getTimerObject(...,true) call will
+        // interrupt the indefinte wait we are about to enter
+        allTimersPosted = true;
+        return false;
+    }
+
+    TimerInfo *t = it.value();
     if (currentTime < t->timeout) {
         // time to wait
@@ -925 +974 @@
     updateCurrentTime();
 
-    while(true) {
-        TimerInfo *t = timersByTimeout.begin().value();
+    TimevalMap::iterator it = timersByTimeout.begin();
+
+    while (it != timersByTimeout.end()) {
+        TimerInfo *t = it.value();
 
         if (currentTime < t->timeout)
             break; // no timer has expired
 
+        if (t->posted) {
+            // ignore the timer since we already posted it
+            ++ it;
+            continue;
+        }
+
         // remove from map
-        timersByTimeout.erase(timersByTimeout.begin());
-
-        // determine next timeout time
+        timersByTimeout.erase(it);
+
+        // determine next timeout time after currentTime
         if (t->interval.tv_sec == 0 && t->interval.tv_usec == 0) {
-            // zero timer; make sure it won't fire again in this loop
-            t->timeout.tv_sec = 0;
-            t->timeout.tv_usec = 1;
-            t->timeout += currentTime;
+            // zero timer
+            t->timeout = currentTime;
         } else {
-            // normal timer; also make sure it won't fire again in this loop
-            t->timeout += t->interval;
-            if (t->timeout < currentTime)
-                t->timeout = currentTime + t->interval;
-        }
+            register qint64 time = t->timeout.tv_sec * 1000ll + t->timeout.tv_usec / 1000ll;
+            register qint64 curr = currentTime.tv_sec * 1000ll + currentTime.tv_usec / 1000ll;
+            register qint64 ival = t->interval.tv_sec * 1000ll + t->interval.tv_usec / 1000ll;
+            curr += (ival - ((curr - time) % ival));
+            t->timeout.tv_sec = curr / 1000ll;
+            t->timeout.tv_usec = (curr % 1000ll) * 1000ll;
+        }
+
+        // set the posted flag to avoid polluting the message queue with timer
+        // messages if the target window is not fast enough to process them
+        t->posted = true;
 
         // reinsert timer (in proper sort order)
@@ -952 +1013 @@
         // post the timer message
         WinPostMsg(t->hwnd, WM_U_SEM_TIMER, MPFROMLONG(t->id), 0);
+
+        // start over
+        it = timersByTimeout.begin();
     }
 
@@ -984 +1048 @@
         return QList<QPair<int, int> >();
     }
-    static QObject *getTimerObject(int timerId);
+    static QObject *getTimerObject(int timerId, bool reset);
 
     static void attachThread() {}
@@ -1092 +1156 @@
         case WM_U_SEM_TIMER: {
             int timerId = LONGFROMMP(mp1);
-            QObject *obj = QSelectThread::getTimerObject(timerId);
+            QObject *obj = QSelectThread::getTimerObject(timerId, true /*reset*/);
 
             if (obj && !timersInSend.contains(timerId)) {