JavaScriptCore-903.tar.gz

[apple/javascriptcore.git] / wtf / ThreadingPthreads.cpp

diff --git a/wtf/ThreadingPthreads.cpp b/wtf/ThreadingPthreads.cpp
index 2feb80829544f4d7ce59cbe8a5ff86e4dfba109d..916aa3656dbac7f383f63e743ffeb6e2810ddec5 100644 (file)
--- a/wtf/ThreadingPthreads.cpp
+++ b/wtf/ThreadingPthreads.cpp
@@ -44,11 +44,19 @@
 
 #if !COMPILER(MSVC)
 #include <limits.h>
 
 #if !COMPILER(MSVC)
 #include <limits.h>

+#include <sched.h>

 #include <sys/time.h>
 #endif
 
 #if OS(ANDROID)
 #include <sys/time.h>
 #endif
 
 #if OS(ANDROID)

-#include "jni_utility.h"
+#include "JNIUtility.h"
+#include "ThreadFunctionInvocation.h"
+#include <wtf/OwnPtr.h>
+#include <wtf/PassOwnPtr.h>
+#endif
+
+#if OS(MAC_OS_X) && !defined(BUILDING_ON_LEOPARD)
+#include <objc/objc-auto.h>

 #endif
 
 namespace WTF {
 #endif
 
 namespace WTF {


@@ -57,10 +65,6 @@ typedef HashMap<ThreadIdentifier, pthread_t> ThreadMap;
 
 static Mutex* atomicallyInitializedStaticMutex;
 
 
 static Mutex* atomicallyInitializedStaticMutex;
 

-#if !OS(DARWIN) || PLATFORM(CHROMIUM) || USE(WEB_THREAD)
-static pthread_t mainThread; // The thread that was the first to call initializeThreading(), which must be the main thread.
-#endif
-

 void clearPthreadHandleForIdentifier(ThreadIdentifier);
 
 static Mutex& threadMapMutex()
 void clearPthreadHandleForIdentifier(ThreadIdentifier);
 
 static Mutex& threadMapMutex()


@@ -71,15 +75,12 @@ static Mutex& threadMapMutex()
 
 void initializeThreading()
 {
 
 void initializeThreading()
 {

-    if (!atomicallyInitializedStaticMutex) {
-        atomicallyInitializedStaticMutex = new Mutex;
-        threadMapMutex();
-        initializeRandomNumberGenerator();
-#if !OS(DARWIN) || PLATFORM(CHROMIUM) || USE(WEB_THREAD)
-        mainThread = pthread_self();
-#endif
-        initializeMainThread();
-    }
+    if (atomicallyInitializedStaticMutex)
+        return;
+
+    atomicallyInitializedStaticMutex = new Mutex;
+    threadMapMutex();
+    initializeRandomNumberGenerator();

 }
 
 void lockAtomicallyInitializedStaticMutex()
 }
 
 void lockAtomicallyInitializedStaticMutex()


@@ -142,38 +143,34 @@ void clearPthreadHandleForIdentifier(ThreadIdentifier id)
 }
 
 #if OS(ANDROID)
 }
 
 #if OS(ANDROID)

-// On the Android platform, threads must be registered with the VM before they run.
-struct ThreadData {
-    ThreadFunction entryPoint;
-    void* arg;
-};
-

 static void* runThreadWithRegistration(void* arg)
 {
 static void* runThreadWithRegistration(void* arg)
 {

-    ThreadData* data = static_cast<ThreadData*>(arg);
+    OwnPtr<ThreadFunctionInvocation> invocation = adoptPtr(static_cast<ThreadFunctionInvocation*>(arg));

     JavaVM* vm = JSC::Bindings::getJavaVM();
     JNIEnv* env;
     void* ret = 0;
     if (vm->AttachCurrentThread(&env, 0) == JNI_OK) {
     JavaVM* vm = JSC::Bindings::getJavaVM();
     JNIEnv* env;
     void* ret = 0;
     if (vm->AttachCurrentThread(&env, 0) == JNI_OK) {

-        ret = data->entryPoint(data->arg);
+        ret = invocation->function(invocation->data);

         vm->DetachCurrentThread();
     }
         vm->DetachCurrentThread();
     }

-    delete data;

     return ret;
 }
 
 ThreadIdentifier createThreadInternal(ThreadFunction entryPoint, void* data, const char*)
 {
     pthread_t threadHandle;
     return ret;
 }
 
 ThreadIdentifier createThreadInternal(ThreadFunction entryPoint, void* data, const char*)
 {
     pthread_t threadHandle;

-    ThreadData* threadData = new ThreadData();
-    threadData->entryPoint = entryPoint;
-    threadData->arg = data;

 
 

-    if (pthread_create(&threadHandle, 0, runThreadWithRegistration, static_cast<void*>(threadData))) {
+    // On the Android platform, threads must be registered with the VM before they run.
+    OwnPtr<ThreadFunctionInvocation> invocation = adoptPtr(new ThreadFunctionInvocation(entryPoint, data));
+
+    if (pthread_create(&threadHandle, 0, runThreadWithRegistration, invocation.get())) {

         LOG_ERROR("Failed to create pthread at entry point %p with data %p", entryPoint, data);
         LOG_ERROR("Failed to create pthread at entry point %p with data %p", entryPoint, data);

-        delete threadData;

         return 0;
     }
         return 0;
     }

+
+    // The thread will take ownership of invocation.
+    invocation.leakPtr();
+

     return establishIdentifierForPthreadHandle(threadHandle);
 }
 #else
     return establishIdentifierForPthreadHandle(threadHandle);
 }
 #else


@@ -197,6 +194,12 @@ void initializeCurrentThreadInternal(const char* threadName)
     UNUSED_PARAM(threadName);
 #endif
 
     UNUSED_PARAM(threadName);
 #endif
 

+#if OS(MAC_OS_X) && !defined(BUILDING_ON_LEOPARD)
+    // All threads that potentially use APIs above the BSD layer must be registered with the Objective-C
+    // garbage collector in case API implementations use garbage-collected memory.
+    objc_registerThreadWithCollector();
+#endif
+

     ThreadIdentifier id = identifierByPthreadHandle(pthread_self());
     ASSERT(id);
     ThreadIdentifierData::initialize(id);
     ThreadIdentifier id = identifierByPthreadHandle(pthread_self());
     ASSERT(id);
     ThreadIdentifierData::initialize(id);


@@ -228,6 +231,11 @@ void detachThread(ThreadIdentifier threadID)
     pthread_detach(pthreadHandle);
 }
 
     pthread_detach(pthreadHandle);
 }
 

+void yield()
+{
+    sched_yield();
+}
+

 ThreadIdentifier currentThread()
 {
     ThreadIdentifier id = ThreadIdentifierData::identifier();
 ThreadIdentifier currentThread()
 {
     ThreadIdentifier id = ThreadIdentifierData::identifier();


@@ -240,18 +248,15 @@ ThreadIdentifier currentThread()
     return id;
 }
 
     return id;
 }
 

-bool isMainThread()
-{
-#if OS(DARWIN) && !PLATFORM(CHROMIUM) && !USE(WEB_THREAD)
-    return pthread_main_np();
-#else
-    return pthread_equal(pthread_self(), mainThread);
-#endif
-}
-

 Mutex::Mutex()
 {
 Mutex::Mutex()
 {

-    pthread_mutex_init(&m_mutex, NULL);
+    pthread_mutexattr_t attr;
+    pthread_mutexattr_init(&attr);
+    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
+
+    pthread_mutex_init(&m_mutex, &attr);
+
+    pthread_mutexattr_destroy(&attr);

 }
 
 Mutex::~Mutex()
 }
 
 Mutex::~Mutex()