Changeset 43366 in webkit for trunk/JavaScriptCore/wtf/ThreadingWin.cpp

Timestamp:

May 7, 2009, 2:24:36 PM (16 years ago)

Author:

[email protected]

Message:

JavaScriptCore:

2009-05-07 Dmitry Titov <​[email protected]>

Reviewed by Alexey Proskuryakov and Adam Roben.

​https://bugs.webkit.org/show_bug.cgi?id=25348
Change WTF::ThreadIdentifier to be an actual (but wrapped) thread id, remove ThreadMap.

• wtf/Threading.h: (WTF::ThreadIdentifier::ThreadIdentifier): (WTF::ThreadIdentifier::isValid): (WTF::ThreadIdentifier::invalidate): (WTF::ThreadIdentifier::platformId): ThreadIdentifier is now a class, containing a PlatformThreadIdentifier and methods that are used across the code on thread ids: construction, comparisons, check for 'valid' state etc. '0' is used as invalid id, which happens to just work with all platform-specific thread id implementations.

All the following files repeatedly reflect the new ThreadIdentifier for each platform.
We remove ThreadMap and threadMapMutex from all of them, remove the functions that
populated/searched/cleared the map and add platform-specific comparison operators
for ThreadIdentifier.

• wtf/gtk/ThreadingGtk.cpp: (WTF::ThreadIdentifier::operator==): (WTF::ThreadIdentifier::operator!=): (WTF::initializeThreading): (WTF::createThreadInternal): (WTF::waitForThreadCompletion): (WTF::currentThread):

• wtf/ThreadingNone.cpp: (WTF::ThreadIdentifier::operator==): (WTF::ThreadIdentifier::operator!=):

• wtf/ThreadingPthreads.cpp: (WTF::ThreadIdentifier::operator==): (WTF::ThreadIdentifier::operator!=): (WTF::initializeThreading): (WTF::createThreadInternal): (WTF::waitForThreadCompletion): (WTF::detachThread): (WTF::currentThread):

• wtf/qt/ThreadingQt.cpp: (WTF::ThreadIdentifier::operator==): (WTF::ThreadIdentifier::operator!=): (WTF::initializeThreading): (WTF::createThreadInternal): (WTF::waitForThreadCompletion): (WTF::currentThread):

• wtf/ThreadingWin.cpp: (WTF::ThreadIdentifier::operator==): (WTF::ThreadIdentifier::operator!=): (WTF::initializeThreading): (WTF::createThreadInternal): All the platforms (except Windows) used a sequential counter as a thread ID and mapped it into platform ID. Windows was using native thread id and mapped it into thread handle. Since we can always obtain a thread handle by thread id, createThread now closes the handle. (WTF::waitForThreadCompletion): obtains another one using OpenThread(id) API. If can not obtain a handle, it means the thread already exited. (WTF::detachThread): (WTF::currentThread): (WTF::detachThreadDeprecated): old function, renamed (for Win Safari 4 beta which uses it for now). (WTF::waitForThreadCompletionDeprecated): same. (WTF::currentThreadDeprecated): same. (WTF::createThreadDeprecated): same.

• bytecode/SamplingTool.h:
• bytecode/SamplingTool.cpp: Use DEFINE_STATIC_LOCAL for a static ThreadIdentifier variable, to avoid static constructor.

• JavaScriptCore.exp: export lists - updated the WTF threading functions decorated names since they now take a different type as a parameter.
• JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def: ditto for Windows, plus added "deprecated" functions that take old parameter type - turns out public beta of Safari 4 uses those, so they need to be kept along for a while.
• JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore_debug.def: ditto.

WebCore:

2009-05-07 Dmitry Titov <​[email protected]>

Reviewed by Alexey Proskuryakov and Adam Roben.

​https://bugs.webkit.org/show_bug.cgi?id=25348
Change WTF::ThreadIdentifier to be an actual (but wrapped) thread id, remove ThreadMap.

Most of the change is in WTF.
Unless noted, all the following files changed to use the new ThreadIdentifier::isValid()
method instead of just doing 'if(m_threadID)' kind of checks, since ThreadIdentifier
is now a class rather then an integer.
Also, there is no need to initialize threadID in constructors to 0 now.

• dom/XMLTokenizerLibxml2.cpp: (WebCore::libxmlLoaderThread): use DEFINE_STATIC_LOCAL and accessor function for static thread id, since now ThreadIdentifier needs construction and we avoid having global initializers. (WebCore::matchFunc): use the new accessor function. (WebCore::openFunc): ditto. (WebCore::createStringParser): ditto. (WebCore::createMemoryParser): ditto.
• loader/icon/IconDatabase.cpp: (WebCore::IconDatabase::open):
• platform/sql/SQLiteDatabase.cpp: (WebCore::SQLiteDatabase::SQLiteDatabase): (WebCore::SQLiteDatabase::close):
• storage/DatabaseThread.cpp: (WebCore::DatabaseThread::start): (WebCore::DatabaseThread::databaseThread): remove m_threadID from debug output.
• storage/LocalStorageThread.cpp: (WebCore::LocalStorageThread::start): (WebCore::LocalStorageThread::scheduleImport): (WebCore::LocalStorageThread::scheduleSync): (WebCore::LocalStorageThread::terminate):
• workers/WorkerThread.cpp: (WebCore::WorkerThread::start): (WebCore::WorkerThread::WorkerThread): (WebCore::WorkerThread::start):

WebKit/win:

2009-05-07 Dmitry Titov <​[email protected]>

Reviewed by Alexey Proskuryakov and Adam Roben.

​https://bugs.webkit.org/show_bug.cgi?id=25348
Change WTF::ThreadIdentifier to be an actual (but wrapped) thread id, remove ThreadMap.

Most of the change is in WTF and WebCore.

• WebKit.vcproj/WebKit.def: replaced decorated names of WTF threading functions with new ones. Also, aliased the old implementations so the public Safari 4 beta can load the old WTF functions which it uses. Next time Safari 4 builds, it will pick up new functions and the deprecated ones can be removed.
• WebKit.vcproj/WebKit_debug.def: same.

File:

• trunk/JavaScriptCore/wtf/ThreadingWin.cpp (modified) (5 diffs)

trunk/JavaScriptCore/wtf/ThreadingWin.cpp

@@ -99 +99 @@
 namespace WTF {
 
+bool ThreadIdentifier::operator==(const ThreadIdentifier& another) const
+{
+    return m_platformId == another.m_platformId;
+}
+
+bool ThreadIdentifier::operator!=(const ThreadIdentifier& another) const
+{
+    return m_platformId != another.m_platformId;
+}
+
 // MS_VC_EXCEPTION, THREADNAME_INFO, and setThreadNameInternal all come from <http://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx>.
 static const DWORD MS_VC_EXCEPTION = 0x406D1388;
@@ -140 +150 @@
 static ThreadIdentifier mainThreadIdentifier;
 
-static Mutex& threadMapMutex()
-{
-    static Mutex mutex;
-    return mutex;
-}
-
 void initializeThreading()
 {
     if (!atomicallyInitializedStaticMutex) {
         atomicallyInitializedStaticMutex = new Mutex;
-        threadMapMutex();
         initializeRandomNumberGenerator();
         initializeMainThread();
@@ -158 +161 @@
 }
 
-static HashMap<DWORD, HANDLE>& threadMap()
-{
-    static HashMap<DWORD, HANDLE> map;
-    return map;
-}
-
-static void storeThreadHandleByIdentifier(DWORD threadID, HANDLE threadHandle)
-{
-    MutexLocker locker(threadMapMutex());
-    ASSERT(!threadMap().contains(threadID));
-    threadMap().add(threadID, threadHandle);
-}
-
-static HANDLE threadHandleForIdentifier(ThreadIdentifier id)
-{
-    MutexLocker locker(threadMapMutex());
-    return threadMap().get(id);
-}
-
-static void clearThreadHandleForIdentifier(ThreadIdentifier id)
-{
-    MutexLocker locker(threadMapMutex());
-    ASSERT(threadMap().contains(id));
-    threadMap().remove(id);
-}
-
 struct ThreadFunctionInvocation {
     ThreadFunctionInvocation(ThreadFunction function, void* data) : function(function), data(data) {}
@@ -209 +186 @@
 {
     unsigned threadIdentifier = 0;
-    ThreadIdentifier threadID = 0;
     ThreadFunctionInvocation* invocation = new ThreadFunctionInvocation(entryPoint, data);
     HANDLE threadHandle = reinterpret_cast<HANDLE>(_beginthreadex(0, 0, wtfThreadEntryPoint, invocation, 0, &threadIdentifier));
     if (!threadHandle) {
         LOG_ERROR("Failed to create thread at entry point %p with data %p: %ld", entryPoint, data, errno);
-        return 0;
-    }
-
-    threadID = static_cast<ThreadIdentifier>(threadIdentifier);
-    storeThreadHandleByIdentifier(threadIdentifier, threadHandle);
-
-    return threadID;
+        return ThreadIdentifier();
+    }
+    // Closes handle only, since we don't need it. The new thread runs until it exits.
+    CloseHandle(threadHandle);
+
+    return ThreadIdentifier(threadIdentifier);
 }
 
 int waitForThreadCompletion(ThreadIdentifier threadID, void** result)
 {
-    ASSERT(threadID);
+    ASSERT(threadID.isValid());
     
-    HANDLE threadHandle = threadHandleForIdentifier(threadID);
+    unsigned threadIdentifier = threadID.platformId();
+    HANDLE threadHandle = OpenThread(SYNCHRONIZE, FALSE, threadIdentifier);
+    // If thread already exited, return immediately.
     if (!threadHandle)
-        LOG_ERROR("ThreadIdentifier %u did not correspond to an active thread when trying to quit", threadID);
+        return WAIT_OBJECT_0;
  
     DWORD joinResult = WaitForSingleObject(threadHandle, INFINITE);
     if (joinResult == WAIT_FAILED)
-        LOG_ERROR("ThreadIdentifier %u was found to be deadlocked trying to quit", threadID);
+        LOG_ERROR("ThreadIdentifier %p was found to be deadlocked trying to quit", threadHandle);
 
     CloseHandle(threadHandle);
-    clearThreadHandleForIdentifier(threadID);
 
     return joinResult;
 }
 
-void detachThread(ThreadIdentifier threadID)
-{
-    ASSERT(threadID);
-    
-    HANDLE threadHandle = threadHandleForIdentifier(threadID);
-    if (threadHandle)
-        CloseHandle(threadHandle);
-    clearThreadHandleForIdentifier(threadID);
+void detachThread(ThreadIdentifier)
+{
 }
 
 ThreadIdentifier currentThread()
 {
-    return static_cast<ThreadIdentifier>(GetCurrentThreadId());
+    return ThreadIdentifier(GetCurrentThreadId());
 }
 
@@ -471 +441 @@
 }
 
+// Deprecated functions. The current build of Safari 4 beta is linked with them so we need to provide
+// the implementation taking PlatformThreadIdentifier instead of ThreadIdentifier. These are not declared
+// in .h file so the next time Safari is built it will 'automatically' switch to new functions.
+// Then deprecated ones can be removed from this file and from JavaScriptCore.def and WebKit.def files.
+// In WebKit.def file, these functions are 'renamed' so their name does not have 'Deprecated' part - this
+// is to avoid having 2 functions with only different type of return value.
+void detachThreadDeprecated(PlatformThreadIdentifier)
+{
+}
+
+int waitForThreadCompletionDeprecated(PlatformThreadIdentifier threadID, void** result)
+{
+    ASSERT(threadID);
+
+    unsigned threadIdentifier = static_cast<unsigned>(threadID);
+    HANDLE threadHandle = OpenThread(SYNCHRONIZE, FALSE, threadIdentifier);
+    // If thread already exited, return immediately.
+    if (!threadHandle)
+        return WAIT_OBJECT_0;
+
+    DWORD joinResult = WaitForSingleObject(threadHandle, INFINITE);
+    if (joinResult == WAIT_FAILED)
+        LOG_ERROR("ThreadIdentifier %p was found to be deadlocked trying to quit", threadHandle);
+
+    CloseHandle(threadHandle);
+
+    return joinResult;
+}
+
+PlatformThreadIdentifier currentThreadDeprecated()
+{
+    return static_cast<PlatformThreadIdentifier>(GetCurrentThreadId());
+}
+
+PlatformThreadIdentifier createThreadDeprecated(ThreadFunction entryPoint, void* data, const char* name)
+{
+    ThreadIdentifier threadID = createThread(entryPoint, data, name);
+    return static_cast<PlatformThreadIdentifier>(threadID.platformId());
+}
+
 } // namespace WTF