Changeset 31864 in webkit for trunk/JavaScriptCore

Timestamp:

Apr 14, 2008, 9:30:13 AM (17 years ago)

Author:

[email protected]

Message:

Reviewed by Adam Roben.

​https://bugs.webkit.org/show_bug.cgi?id=18488
FastMalloc doesn't release thread-specific data on Windows

• wtf/ThreadingWin.cpp: (WTF::threadMapMutex): (WTF::initializeThreading): Call threadMapMutex once to initialize the static safely. (WTF::ThreadFunctionInvocation::ThreadFunctionInvocation): Added a structure to wrap thread entry point and arguments. (WTF::wtfThreadEntryPoint): Make sure to end all WTF threads with pthread_exit(), to give pthreads-win32 a chance to call destructors of thread-specific data. (WTF::createThread): Use _beginthreadex instead of CreateThread, because MSDN says so. Also removed a call to CreateEvent, for which I could see no reason at all.

Location:

trunk/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• wtf/ThreadingWin.cpp (modified) (5 diffs)

trunk/JavaScriptCore/ChangeLog

@@ +1 @@
+2008-04-14  Alexey Proskuryakov  <[email protected]>
+
+        Reviewed by Adam Roben.
+
+        https://bugs.webkit.org/show_bug.cgi?id=18488
+        FastMalloc doesn't release thread-specific data on Windows
+
+        * wtf/ThreadingWin.cpp:
+        (WTF::threadMapMutex): (WTF::initializeThreading): Call threadMapMutex once to initialize the static safely.
+        (WTF::ThreadFunctionInvocation::ThreadFunctionInvocation): Added a structure to wrap thread entry point and arguments.
+        (WTF::wtfThreadEntryPoint): Make sure to end all WTF threads with pthread_exit(), to give pthreads-win32 a chance to call
+        destructors of thread-specific data.
+        (WTF::createThread): Use _beginthreadex instead of CreateThread, because MSDN says so. Also removed a call to CreateEvent,
+        for which I could see no reason at all.
+
 2008-04-14  Alexey Proskuryakov  <[email protected]>
 

trunk/JavaScriptCore/wtf/ThreadingWin.cpp

@@ -65 +65 @@
 
 #include "MainThread.h"
+#include <process.h>
 #include <windows.h>
 #include <wtf/HashMap.h>
 #include <wtf/MathExtras.h>
 
+#if PLATFORM(WIN)
+// Currently, Apple's Windows port uses a mixture of native and pthreads functions in FastMalloc.
+// To ensure that thread-specific data is properly destroyed, we need to end each thread with pthread_exit().
+#include <pthreads.h>
+#endif
+
 namespace WTF {
 
@@ -74 +81 @@
 
 static ThreadIdentifier mainThreadIdentifier;
+
+static Mutex& threadMapMutex()
+{
+    static Mutex mutex;
+    return mutex;
+}
 
 void initializeThreading()
@@ -79 +92 @@
     if (!atomicallyInitializedStaticMutex) {
         atomicallyInitializedStaticMutex = new Mutex;
+        threadMapMutex();
         wtf_random_init();
         initializeMainThread();
@@ -85 +99 @@
 }
 
-static Mutex& threadMapMutex()
-{
-    static Mutex mutex;
-    return mutex;
-}
-
 static HashMap<DWORD, HANDLE>& threadMap()
 {
@@ -116 +124 @@
 }
 
+struct ThreadFunctionInvocation {
+    ThreadFunctionInvocation(ThreadFunction function, void* data) : function(function), data(data) {}
+
+    ThreadFunction function;
+    void* data;
+};
+
+static unsigned __stdcall wtfThreadEntryPoint(void* param)
+{
+    ThreadFunctionInvocation invocation = *static_cast<ThreadFunctionInvocation*>(param);
+    delete static_cast<ThreadFunctionInvocation*>(param);
+
+    void* result = invocation.function(invocation.data);
+
+#if PLATFORM(WIN)
+    // pthreads-win32 knows how to work with threads created with Win32 or CRT functions, so it's OK to mix APIs.
+    pthread_exit(result);
+#endif
+
+    return reinterpret_cast<unsigned>(result);
+}
+
 ThreadIdentifier createThread(ThreadFunction entryPoint, void* data)
 {
-    DWORD threadIdentifier = 0;
+    unsigned threadIdentifier = 0;
     ThreadIdentifier threadID = 0;
-    HANDLE hEvent = ::CreateEvent(0, FALSE, FALSE, 0);
-    HANDLE threadHandle = ::CreateThread(0, 0, (LPTHREAD_START_ROUTINE)entryPoint, data, 0, &threadIdentifier);
+    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", entryPoint, data);
+        LOG_ERROR("Failed to create thread at entry point %p with data %p: %ld", entryPoint, data, errno);
         return 0;
     }