wtf/qt/ThreadingQt.cpp

   1 /*
   2  * Copyright (C) 2007 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 #include "config.h"
  30 #include "Threading.h"
  31
  32 #if !ENABLE(SINGLE_THREADED)
  33
  34 #include "CurrentTime.h"
  35 #include "HashMap.h"
  36 #include "MainThread.h"
  37 #include "RandomNumberSeed.h"
  38
  39 #include <QCoreApplication>
  40 #include <QMutex>
  41 #include <QThread>
  42 #include <QWaitCondition>
  43
  44 namespace WTF {
  45
  46 class ThreadPrivate : public QThread {
  47 public:
  48     ThreadPrivate(ThreadFunction entryPoint, void* data);
  49     void run();
  50     void* getReturnValue() { return m_returnValue; }
  51 private:
  52     void* m_data;
  53     ThreadFunction m_entryPoint;
  54     void* m_returnValue;
  55 };
  56
  57 ThreadPrivate::ThreadPrivate(ThreadFunction entryPoint, void* data)
  58     : m_data(data)
  59     , m_entryPoint(entryPoint)
  60     , m_returnValue(0)
  61 {
  62 }
  63
  64 void ThreadPrivate::run()
  65 {
  66     m_returnValue = m_entryPoint(m_data);
  67 }
  68
  69 class ThreadMonitor : public QObject {
  70     Q_OBJECT
  71 public:
  72     static ThreadMonitor * instance()
  73     {
  74         static ThreadMonitor *instance = new ThreadMonitor();
  75         return instance;
  76     }
  77
  78 public Q_SLOTS:
  79     void threadFinished()
  80     {
  81         sender()->deleteLater();
  82     }
  83 };
  84
  85 static Mutex* atomicallyInitializedStaticMutex;
  86
  87 static Mutex& threadMapMutex()
  88 {
  89     static Mutex mutex;
  90     return mutex;
  91 }
  92
  93 static HashMap<ThreadIdentifier, QThread*>& threadMap()
  94 {
  95     static HashMap<ThreadIdentifier, QThread*> map;
  96     return map;
  97 }
  98
  99 static ThreadIdentifier identifierByQthreadHandle(QThread*& thread)
 100 {
 101     MutexLocker locker(threadMapMutex());
 102
 103     HashMap<ThreadIdentifier, QThread*>::iterator i = threadMap().begin();
 104     for (; i != threadMap().end(); ++i) {
 105         if (i->second == thread)
 106             return i->first;
 107     }
 108
 109     return 0;
 110 }
 111
 112 static ThreadIdentifier establishIdentifierForThread(QThread*& thread)
 113 {
 114     ASSERT(!identifierByQthreadHandle(thread));
 115
 116     MutexLocker locker(threadMapMutex());
 117
 118     static ThreadIdentifier identifierCount = 1;
 119
 120     threadMap().add(identifierCount, thread);
 121
 122     return identifierCount++;
 123 }
 124
 125 static void clearThreadForIdentifier(ThreadIdentifier id)
 126 {
 127     MutexLocker locker(threadMapMutex());
 128
 129     ASSERT(threadMap().contains(id));
 130
 131     threadMap().remove(id);
 132 }
 133
 134 static QThread* threadForIdentifier(ThreadIdentifier id)
 135 {
 136     MutexLocker locker(threadMapMutex());
 137
 138     return threadMap().get(id);
 139 }
 140
 141 void initializeThreading()
 142 {
 143     if (!atomicallyInitializedStaticMutex) {
 144         atomicallyInitializedStaticMutex = new Mutex;
 145         threadMapMutex();
 146         initializeRandomNumberGenerator();
 147     }
 148 }
 149
 150 void lockAtomicallyInitializedStaticMutex()
 151 {
 152     ASSERT(atomicallyInitializedStaticMutex);
 153     atomicallyInitializedStaticMutex->lock();
 154 }
 155
 156 void unlockAtomicallyInitializedStaticMutex()
 157 {
 158     atomicallyInitializedStaticMutex->unlock();
 159 }
 160
 161 ThreadIdentifier createThreadInternal(ThreadFunction entryPoint, void* data, const char*)
 162 {
 163     ThreadPrivate* thread = new ThreadPrivate(entryPoint, data);
 164     if (!thread) {
 165         LOG_ERROR("Failed to create thread at entry point %p with data %p", entryPoint, data);
 166         return 0;
 167     }
 168
 169     QObject::connect(thread, SIGNAL(finished()), ThreadMonitor::instance(), SLOT(threadFinished()));
 170
 171     thread->start();
 172
 173     QThread* threadRef = static_cast<QThread*>(thread);
 174
 175     return establishIdentifierForThread(threadRef);
 176 }
 177
 178 void initializeCurrentThreadInternal(const char*)
 179 {
 180 }
 181
 182 int waitForThreadCompletion(ThreadIdentifier threadID, void** result)
 183 {
 184     ASSERT(threadID);
 185
 186     QThread* thread = threadForIdentifier(threadID);
 187
 188     bool res = thread->wait();
 189
 190     clearThreadForIdentifier(threadID);
 191     if (result)
 192         *result = static_cast<ThreadPrivate*>(thread)->getReturnValue();
 193
 194     return !res;
 195 }
 196
 197 void detachThread(ThreadIdentifier threadID)
 198 {
 199     ASSERT(threadID);
 200     clearThreadForIdentifier(threadID);
 201 }
 202
 203 ThreadIdentifier currentThread()
 204 {
 205     QThread* currentThread = QThread::currentThread();
 206     if (ThreadIdentifier id = identifierByQthreadHandle(currentThread))
 207         return id;
 208     return establishIdentifierForThread(currentThread);
 209 }
 210
 211 Mutex::Mutex()
 212     : m_mutex(new QMutex())
 213 {
 214 }
 215
 216 Mutex::~Mutex()
 217 {
 218     delete m_mutex;
 219 }
 220
 221 void Mutex::lock()
 222 {
 223     m_mutex->lock();
 224 }
 225
 226 bool Mutex::tryLock()
 227 {
 228     return m_mutex->tryLock();
 229 }
 230
 231 void Mutex::unlock()
 232 {
 233     m_mutex->unlock();
 234 }
 235
 236 ThreadCondition::ThreadCondition()
 237     : m_condition(new QWaitCondition())
 238 {
 239 }
 240
 241 ThreadCondition::~ThreadCondition()
 242 {
 243     delete m_condition;
 244 }
 245
 246 void ThreadCondition::wait(Mutex& mutex)
 247 {
 248     m_condition->wait(mutex.impl());
 249 }
 250
 251 bool ThreadCondition::timedWait(Mutex& mutex, double absoluteTime)
 252 {
 253     double currentTime = WTF::currentTime();
 254
 255     // Time is in the past - return immediately.
 256     if (absoluteTime < currentTime)
 257         return false;
 258
 259     // Time is too far in the future (and would overflow unsigned long) - wait forever.
 260     if (absoluteTime - currentTime > static_cast<double>(INT_MAX) / 1000.0) {
 261         wait(mutex);
 262         return true;
 263     }
 264
 265     double intervalMilliseconds = (absoluteTime - currentTime) * 1000.0;
 266     return m_condition->wait(mutex.impl(), static_cast<unsigned long>(intervalMilliseconds));
 267 }
 268
 269 void ThreadCondition::signal()
 270 {
 271     m_condition->wakeOne();
 272 }
 273
 274 void ThreadCondition::broadcast()
 275 {
 276     m_condition->wakeAll();
 277 }
 278
 279 } // namespace WebCore
 280
 281 #include "ThreadingQt.moc"
 282
 283 #endif