wtf/ThreadingPthreads.cpp

   1 /*
   2  * Copyright (C) 2007, 2009 Apple Inc. All rights reserved.
   3  * Copyright (C) 2007 Justin Haygood (jhaygood@reaktix.com)
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1.  Redistributions of source code must retain the above copyright
  10  *     notice, this list of conditions and the following disclaimer.
  11  * 2.  Redistributions in binary form must reproduce the above copyright
  12  *     notice, this list of conditions and the following disclaimer in the
  13  *     documentation and/or other materials provided with the distribution.
  14  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
  15  *     its contributors may be used to endorse or promote products derived
  16  *     from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #include "config.h"
  31 #include "Threading.h"
  32
  33 #if USE(PTHREADS)
  34
  35 #include "CurrentTime.h"
  36 #include "HashMap.h"
  37 #include "MainThread.h"
  38 #include "RandomNumberSeed.h"
  39 #include "StdLibExtras.h"
  40 #include "ThreadIdentifierDataPthreads.h"
  41 #include "ThreadSpecific.h"
  42 #include "UnusedParam.h"
  43 #include <errno.h>
  44
  45 #if !COMPILER(MSVC)
  46 #include <limits.h>
  47 #include <sched.h>
  48 #include <sys/time.h>
  49 #endif
  50
  51 #if OS(ANDROID)
  52 #include "JNIUtility.h"
  53 #include "ThreadFunctionInvocation.h"
  54 #include <wtf/OwnPtr.h>
  55 #include <wtf/PassOwnPtr.h>
  56 #endif
  57
  58 #if OS(MAC_OS_X) && !defined(BUILDING_ON_LEOPARD)
  59 #include <objc/objc-auto.h>
  60 #endif
  61
  62 namespace WTF {
  63
  64 typedef HashMap<ThreadIdentifier, pthread_t> ThreadMap;
  65
  66 static Mutex* atomicallyInitializedStaticMutex;
  67
  68 void clearPthreadHandleForIdentifier(ThreadIdentifier);
  69
  70 static Mutex& threadMapMutex()
  71 {
  72     DEFINE_STATIC_LOCAL(Mutex, mutex, ());
  73     return mutex;
  74 }
  75
  76 void initializeThreading()
  77 {
  78     if (atomicallyInitializedStaticMutex)
  79         return;
  80
  81     atomicallyInitializedStaticMutex = new Mutex;
  82     threadMapMutex();
  83     initializeRandomNumberGenerator();
  84 }
  85
  86 void lockAtomicallyInitializedStaticMutex()
  87 {
  88     ASSERT(atomicallyInitializedStaticMutex);
  89     atomicallyInitializedStaticMutex->lock();
  90 }
  91
  92 void unlockAtomicallyInitializedStaticMutex()
  93 {
  94     atomicallyInitializedStaticMutex->unlock();
  95 }
  96
  97 static ThreadMap& threadMap()
  98 {
  99     DEFINE_STATIC_LOCAL(ThreadMap, map, ());
 100     return map;
 101 }
 102
 103 static ThreadIdentifier identifierByPthreadHandle(const pthread_t& pthreadHandle)
 104 {
 105     MutexLocker locker(threadMapMutex());
 106
 107     ThreadMap::iterator i = threadMap().begin();
 108     for (; i != threadMap().end(); ++i) {
 109         if (pthread_equal(i->second, pthreadHandle))
 110             return i->first;
 111     }
 112
 113     return 0;
 114 }
 115
 116 static ThreadIdentifier establishIdentifierForPthreadHandle(const pthread_t& pthreadHandle)
 117 {
 118     ASSERT(!identifierByPthreadHandle(pthreadHandle));
 119
 120     MutexLocker locker(threadMapMutex());
 121
 122     static ThreadIdentifier identifierCount = 1;
 123
 124     threadMap().add(identifierCount, pthreadHandle);
 125
 126     return identifierCount++;
 127 }
 128
 129 static pthread_t pthreadHandleForIdentifier(ThreadIdentifier id)
 130 {
 131     MutexLocker locker(threadMapMutex());
 132
 133     return threadMap().get(id);
 134 }
 135
 136 void clearPthreadHandleForIdentifier(ThreadIdentifier id)
 137 {
 138     MutexLocker locker(threadMapMutex());
 139
 140     ASSERT(threadMap().contains(id));
 141
 142     threadMap().remove(id);
 143 }
 144
 145 #if OS(ANDROID)
 146 static void* runThreadWithRegistration(void* arg)
 147 {
 148     OwnPtr<ThreadFunctionInvocation> invocation = adoptPtr(static_cast<ThreadFunctionInvocation*>(arg));
 149     JavaVM* vm = JSC::Bindings::getJavaVM();
 150     JNIEnv* env;
 151     void* ret = 0;
 152     if (vm->AttachCurrentThread(&env, 0) == JNI_OK) {
 153         ret = invocation->function(invocation->data);
 154         vm->DetachCurrentThread();
 155     }
 156     return ret;
 157 }
 158
 159 ThreadIdentifier createThreadInternal(ThreadFunction entryPoint, void* data, const char*)
 160 {
 161     pthread_t threadHandle;
 162
 163     // On the Android platform, threads must be registered with the VM before they run.
 164     OwnPtr<ThreadFunctionInvocation> invocation = adoptPtr(new ThreadFunctionInvocation(entryPoint, data));
 165
 166     if (pthread_create(&threadHandle, 0, runThreadWithRegistration, invocation.get())) {
 167         LOG_ERROR("Failed to create pthread at entry point %p with data %p", entryPoint, data);
 168         return 0;
 169     }
 170
 171     // The thread will take ownership of invocation.
 172     invocation.leakPtr();
 173
 174     return establishIdentifierForPthreadHandle(threadHandle);
 175 }
 176 #else
 177 ThreadIdentifier createThreadInternal(ThreadFunction entryPoint, void* data, const char*)
 178 {
 179     pthread_t threadHandle;
 180     if (pthread_create(&threadHandle, 0, entryPoint, data)) {
 181         LOG_ERROR("Failed to create pthread at entry point %p with data %p", entryPoint, data);
 182         return 0;
 183     }
 184
 185     return establishIdentifierForPthreadHandle(threadHandle);
 186 }
 187 #endif
 188
 189 void initializeCurrentThreadInternal(const char* threadName)
 190 {
 191 #if HAVE(PTHREAD_SETNAME_NP)
 192     pthread_setname_np(threadName);
 193 #else
 194     UNUSED_PARAM(threadName);
 195 #endif
 196
 197 #if OS(MAC_OS_X) && !defined(BUILDING_ON_LEOPARD)
 198     // All threads that potentially use APIs above the BSD layer must be registered with the Objective-C
 199     // garbage collector in case API implementations use garbage-collected memory.
 200     objc_registerThreadWithCollector();
 201 #endif
 202
 203     ThreadIdentifier id = identifierByPthreadHandle(pthread_self());
 204     ASSERT(id);
 205     ThreadIdentifierData::initialize(id);
 206 }
 207
 208 int waitForThreadCompletion(ThreadIdentifier threadID, void** result)
 209 {
 210     ASSERT(threadID);
 211
 212     pthread_t pthreadHandle = pthreadHandleForIdentifier(threadID);
 213     if (!pthreadHandle)
 214         return 0;
 215
 216     int joinResult = pthread_join(pthreadHandle, result);
 217     if (joinResult == EDEADLK)
 218         LOG_ERROR("ThreadIdentifier %u was found to be deadlocked trying to quit", threadID);
 219
 220     return joinResult;
 221 }
 222
 223 void detachThread(ThreadIdentifier threadID)
 224 {
 225     ASSERT(threadID);
 226
 227     pthread_t pthreadHandle = pthreadHandleForIdentifier(threadID);
 228     if (!pthreadHandle)
 229         return;
 230
 231     pthread_detach(pthreadHandle);
 232 }
 233
 234 void yield()
 235 {
 236     sched_yield();
 237 }
 238
 239 ThreadIdentifier currentThread()
 240 {
 241     ThreadIdentifier id = ThreadIdentifierData::identifier();
 242     if (id)
 243         return id;
 244
 245     // Not a WTF-created thread, ThreadIdentifier is not established yet.
 246     id = establishIdentifierForPthreadHandle(pthread_self());
 247     ThreadIdentifierData::initialize(id);
 248     return id;
 249 }
 250
 251 Mutex::Mutex()
 252 {
 253     pthread_mutexattr_t attr;
 254     pthread_mutexattr_init(&attr);
 255     pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
 256
 257     pthread_mutex_init(&m_mutex, &attr);
 258
 259     pthread_mutexattr_destroy(&attr);
 260 }
 261
 262 Mutex::~Mutex()
 263 {
 264     pthread_mutex_destroy(&m_mutex);
 265 }
 266
 267 void Mutex::lock()
 268 {
 269     int result = pthread_mutex_lock(&m_mutex);
 270     ASSERT_UNUSED(result, !result);
 271 }
 272
 273 bool Mutex::tryLock()
 274 {
 275     int result = pthread_mutex_trylock(&m_mutex);
 276
 277     if (result == 0)
 278         return true;
 279     if (result == EBUSY)
 280         return false;
 281
 282     ASSERT_NOT_REACHED();
 283     return false;
 284 }
 285
 286 void Mutex::unlock()
 287 {
 288     int result = pthread_mutex_unlock(&m_mutex);
 289     ASSERT_UNUSED(result, !result);
 290 }
 291
 292 #if HAVE(PTHREAD_RWLOCK)
 293 ReadWriteLock::ReadWriteLock()
 294 {
 295     pthread_rwlock_init(&m_readWriteLock, NULL);
 296 }
 297
 298 ReadWriteLock::~ReadWriteLock()
 299 {
 300     pthread_rwlock_destroy(&m_readWriteLock);
 301 }
 302
 303 void ReadWriteLock::readLock()
 304 {
 305     int result = pthread_rwlock_rdlock(&m_readWriteLock);
 306     ASSERT_UNUSED(result, !result);
 307 }
 308
 309 bool ReadWriteLock::tryReadLock()
 310 {
 311     int result = pthread_rwlock_tryrdlock(&m_readWriteLock);
 312
 313     if (result == 0)
 314         return true;
 315     if (result == EBUSY || result == EAGAIN)
 316         return false;
 317
 318     ASSERT_NOT_REACHED();
 319     return false;
 320 }
 321
 322 void ReadWriteLock::writeLock()
 323 {
 324     int result = pthread_rwlock_wrlock(&m_readWriteLock);
 325     ASSERT_UNUSED(result, !result);
 326 }
 327
 328 bool ReadWriteLock::tryWriteLock()
 329 {
 330     int result = pthread_rwlock_trywrlock(&m_readWriteLock);
 331
 332     if (result == 0)
 333         return true;
 334     if (result == EBUSY || result == EAGAIN)
 335         return false;
 336
 337     ASSERT_NOT_REACHED();
 338     return false;
 339 }
 340
 341 void ReadWriteLock::unlock()
 342 {
 343     int result = pthread_rwlock_unlock(&m_readWriteLock);
 344     ASSERT_UNUSED(result, !result);
 345 }
 346 #endif  // HAVE(PTHREAD_RWLOCK)
 347
 348 ThreadCondition::ThreadCondition()
 349 {
 350     pthread_cond_init(&m_condition, NULL);
 351 }
 352
 353 ThreadCondition::~ThreadCondition()
 354 {
 355     pthread_cond_destroy(&m_condition);
 356 }
 357
 358 void ThreadCondition::wait(Mutex& mutex)
 359 {
 360     int result = pthread_cond_wait(&m_condition, &mutex.impl());
 361     ASSERT_UNUSED(result, !result);
 362 }
 363
 364 bool ThreadCondition::timedWait(Mutex& mutex, double absoluteTime)
 365 {
 366     if (absoluteTime < currentTime())
 367         return false;
 368
 369     if (absoluteTime > INT_MAX) {
 370         wait(mutex);
 371         return true;
 372     }
 373
 374     int timeSeconds = static_cast<int>(absoluteTime);
 375     int timeNanoseconds = static_cast<int>((absoluteTime - timeSeconds) * 1E9);
 376
 377     timespec targetTime;
 378     targetTime.tv_sec = timeSeconds;
 379     targetTime.tv_nsec = timeNanoseconds;
 380
 381     return pthread_cond_timedwait(&m_condition, &mutex.impl(), &targetTime) == 0;
 382 }
 383
 384 void ThreadCondition::signal()
 385 {
 386     int result = pthread_cond_signal(&m_condition);
 387     ASSERT_UNUSED(result, !result);
 388 }
 389
 390 void ThreadCondition::broadcast()
 391 {
 392     int result = pthread_cond_broadcast(&m_condition);
 393     ASSERT_UNUSED(result, !result);
 394 }
 395
 396 } // namespace WTF
 397
 398 #endif // USE(PTHREADS)