Changeset 30849 in webkit for trunk/JavaScriptCore/wtf

Timestamp:

Mar 6, 2008, 10:55:02 AM (17 years ago)

Author:

[email protected]

Message:

JavaScriptCore:

Reviewed by Darin

Add a timedWait() method to ThreadCondition

• JavaScriptCore.exp:

• wtf/Threading.h:

• wtf/ThreadingGtk.cpp: (WTF::ThreadCondition::timedWait):

• wtf/ThreadingNone.cpp: (WTF::ThreadCondition::timedWait):

• wtf/ThreadingPthreads.cpp: (WTF::ThreadCondition::timedWait):

• wtf/ThreadingWin.cpp: (WTF::ThreadCondition::timedWait): Needs implementation

WebKitTools:

Reviewed by Darin

Added a cross-platform Watchdog thread to DRT.

The current watchdog in both DRTWin and DRTMac is Timer based. Therefore, deadlocks and long running
main thread hangs still affect DRT.

By placing the watchdog on a thread and having DRT "check in" after each test, long-running hangs
and true deadlocks can be caught.

There is one hook for platform specific code. As I did my development and testing on Mac, and Mac has
sample available, the Mac implementation of this hook samples the process before it is killed.

I arbitrarily chose 30 seconds as the timeout for now - this can be tweaked easily if we find a need.

• DumpRenderTree/DumpRenderTree.xcodeproj/project.pbxproj:
• DumpRenderTree/mac/Configurations/Base.xcconfig: Added LINKER_DISPLAYS_MANGLED_NAMES

• DumpRenderTree/ForwardingHeaders/wtf/Locker.h: Added.
• DumpRenderTree/ForwardingHeaders/wtf/Threading.h: Added.

• DumpRenderTree/Watchdog.cpp: Added. (Watchdog::Watchdog): (Watchdog::~Watchdog): (Watchdog::start): (Watchdog::stop): (Watchdog::checkIn): (Watchdog::setWatchdogInterval): (Watchdog::handleHang): (Watchdog::watchdogThreadStart): (Watchdog::watchdogThread):
• DumpRenderTree/Watchdog.h: Added.

• DumpRenderTree/mac/WatchdogMac.h: Added.
• DumpRenderTree/mac/WatchdogMac.mm: Added. (WatchdogMac::handleHang): Sample the process and write it out to a file

• DumpRenderTree/mac/DumpRenderTree.mm: (dumpRenderTree): Setup and start the watchdog before running any tests (runTest): Checkin with the watchdog after each test

Location:

trunk/JavaScriptCore/wtf

Files:

• Threading.h (modified) (1 diff)
• ThreadingGtk.cpp (modified) (1 diff)
• ThreadingNone.cpp (modified) (1 diff)
• ThreadingPthreads.cpp (modified) (2 diffs)
• ThreadingWin.cpp (modified) (1 diff)

trunk/JavaScriptCore/wtf/Threading.h

@@ -159 +159 @@
     
     void wait(Mutex& mutex);
+    // Returns true if the condition was signaled before the timeout, false if the timeout was reached
+    bool timedWait(Mutex&, double interval);
     void signal();
     void broadcast();

trunk/JavaScriptCore/wtf/ThreadingGtk.cpp

@@ -177 +177 @@
 }
 
+bool ThreadCondition::timedWait(Mutex& mutex, double interval)
+{
+    if (interval < 0.0) {
+        wait(mutex);
+        return true;
+    }
+    
+    int intervalSeconds = static_cast<int>(interval);
+    int intervalMicroseconds = static_cast<int>((interval - intervalSeconds) * 1000000.0);
+    
+    GTimeVal targetTime;
+    g_get_current_time(&targetTime);
+        
+    targetTime.tv_sec += intervalSeconds;
+    targetTime.tv_usec += intervalMicroseconds;
+    if (targetTime.tv_usec > 1000000) {
+        targetTime.tv_usec -= 1000000;
+        targetTime.tv_sec++;
+    }
+
+    return g_cond_timedwait(m_condition, mutex.impl(), &targetTime);
+}
+
 void ThreadCondition::signal()
 {

trunk/JavaScriptCore/wtf/ThreadingNone.cpp

@@ -48 +48 @@
 ThreadCondition::~ThreadCondition() {}
 void ThreadCondition::wait(Mutex& mutex) {}
+bool ThreadCondition::timedWait(Mutex& mutex, double interval) { return false; }
 void ThreadCondition::signal() {}
 void ThreadCondition::broadcast() {}

trunk/JavaScriptCore/wtf/ThreadingPthreads.cpp

@@ -33 +33 @@
 
 #include <errno.h>
+#include <time.h>
 
 namespace WTF {
@@ -185 +186 @@
         ASSERT(false);
 }
-    
+
+bool ThreadCondition::timedWait(Mutex& mutex, double interval)
+{
+    if (interval < 0.0) {
+        wait(mutex);
+        return true;
+    }
+    
+    int intervalSeconds = static_cast<int>(interval);
+    int intervalMicroseconds = static_cast<int>((interval - intervalSeconds) * 1000000.0);
+    
+    // Current time comes in sec/microsec
+    timeval currentTime;
+    gettimeofday(&currentTime, NULL);
+    
+    // Target time comes in sec/nanosec
+    timespec targetTime;
+    targetTime.tv_sec = currentTime.tv_sec + intervalSeconds;
+    targetTime.tv_nsec = (currentTime.tv_usec + intervalMicroseconds) * 1000;
+    if (targetTime.tv_nsec > 1000000000) {
+        targetTime.tv_nsec -= 1000000000;
+        targetTime.tv_sec++;
+    }
+
+    return pthread_cond_timedwait(&m_condition, &mutex.impl(), &targetTime) == 0;
+}
+
 void ThreadCondition::signal()
 {

trunk/JavaScriptCore/wtf/ThreadingWin.cpp

@@ -284 +284 @@
 
     ::EnterCriticalSection (&cs.m_internalMutex);
+}
+
+bool ThreadCondition::timedWait(Mutex& mutex, double interval)
+{
+    // Empty for now
+    ASSERT(false);
 }