Changeset 43366 in webkit for trunk/JavaScriptCore/wtf


Ignore:
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.
Location:
trunk/JavaScriptCore/wtf
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/wtf/CrossThreadRefCounted.h

    r41536 r43366  
    7575            : m_threadSafeRefCounter(threadedCounter)
    7676            , m_data(data)
    77 #ifndef NDEBUG
    78             , m_threadId(0)
    79 #endif
    8077        {
    8178        }
    … …  
    10097    void CrossThreadRefCounted<T>::ref()
    10198    {
    102         ASSERT(!m_threadId || m_threadId == currentThread());
     99        ASSERT(!m_threadId.isValid() || m_threadId == currentThread());
    103100        m_refCounter.ref();
    104101#ifndef NDEBUG
    … …  
    108105        // is a heuristic but it seems to always work and has helped
    109106        // find some bugs.
    110         if (!m_threadId && m_refCounter.refCount() == 2)
     107        if (!m_threadId.isValid() && m_refCounter.refCount() == 2)
    111108            m_threadId = currentThread();
    112109#endif
    … …  
    116113    void CrossThreadRefCounted<T>::deref()
    117114    {
    118         ASSERT(!m_threadId || m_threadId == currentThread());
     115        ASSERT(!m_threadId.isValid() || m_threadId == currentThread());
    119116        if (m_refCounter.derefBase()) {
    120117            threadSafeDeref();
    … …  
    125122            // is safe to be passed to another thread at this point.
    126123            if (m_threadId && m_refCounter.refCount() == 1)
    127                 m_threadId = 0;
     124                m_threadId.invalidate();
    128125#endif
    129126        }

  • trunk/JavaScriptCore/wtf/Threading.h

    r41605 r43366  
    8686typedef struct _GMutex GMutex;
    8787typedef struct _GCond GCond;
     88typedef struct _GThread GThread;
    8889#endif
    8990
    … …  
    9293QT_BEGIN_NAMESPACE
    9394class QMutex;
     95class QThread;
    9496class QWaitCondition;
    9597QT_END_NAMESPACE
    … …  
    106108namespace WTF {
    107109
    108 typedef uint32_t ThreadIdentifier;
    109 typedef void* (*ThreadFunction)(void* argument);
    110 
    111 // Returns 0 if thread creation failed.
    112 // The thread name must be a literal since on some platforms it's passed in to the thread.
    113 ThreadIdentifier createThread(ThreadFunction, void*, const char* threadName);
    114 
    115 // Internal platform-specific createThread implementation.
    116 ThreadIdentifier createThreadInternal(ThreadFunction, void*, const char* threadName);
    117 
    118 // Called in the thread during initialization.
    119 // Helpful for platforms where the thread name must be set from within the thread.
    120 void setThreadNameInternal(const char* threadName);
    121 
    122 ThreadIdentifier currentThread();
    123 bool isMainThread();
    124 int waitForThreadCompletion(ThreadIdentifier, void**);
    125 void detachThread(ThreadIdentifier);
    126 
    127110#if USE(PTHREADS)
    128111typedef pthread_mutex_t PlatformMutex;
    129112typedef pthread_cond_t PlatformCondition;
     113typedef pthread_t PlatformThreadIdentifier;
    130114#elif PLATFORM(GTK)
    131115typedef GOwnPtr<GMutex> PlatformMutex;
    132116typedef GOwnPtr<GCond> PlatformCondition;
     117typedef GThread* PlatformThreadIdentifier;
    133118#elif PLATFORM(QT)
    134119typedef QT_PREPEND_NAMESPACE(QMutex)* PlatformMutex;
    135120typedef QT_PREPEND_NAMESPACE(QWaitCondition)* PlatformCondition;
     121typedef QT_PREPEND_NAMESPACE(QThread)* PlatformThreadIdentifier;
    136122#elif PLATFORM(WIN_OS)
    137123struct PlatformMutex {
    … …  
    150136    void signal(bool unblockAll);
    151137};
     138typedef unsigned PlatformThreadIdentifier;
    152139#else
    153140typedef void* PlatformMutex;
    … …  
    155142#endif
    156143   
     144// Platform-independent wrapper for thread id. Assignable and copyable.
     145// The only way to obtain a valid ThreadIdentifier is from createThread(...) or currentThread() functions.
     146// ThreadIdentifier remains valid for as long as its thread is alive and is not automatically invalidated
     147// when thread terminates. Since platform-dependent thread ids can be recycled, stale ThreadIdentifier
     148// may reference a completely unrelated thread after its original thread terminates.
     149class ThreadIdentifier {
     150public:
     151    ThreadIdentifier()
     152        : m_platformId(0)
     153    {
     154        ASSERT(!isValid());
     155    }
     156
     157    explicit ThreadIdentifier(PlatformThreadIdentifier platformId)
     158        : m_platformId(platformId)
     159    {
     160        ASSERT(isValid());
     161    }
     162
     163    bool isValid() const  { return m_platformId; }
     164    void invalidate() { m_platformId = 0; }
     165
     166    bool operator==(const ThreadIdentifier&) const;
     167    bool operator!=(const ThreadIdentifier&) const;
     168
     169    PlatformThreadIdentifier platformId() const { return m_platformId;  }
     170
     171private:
     172    PlatformThreadIdentifier m_platformId;
     173};
     174
     175typedef void* (*ThreadFunction)(void* argument);
     176
     177// Returns invalid identifier if thread creation failed.
     178// The thread name must be a literal since on some platforms it's passed in to the thread.
     179ThreadIdentifier createThread(ThreadFunction, void*, const char* threadName);
     180
     181// Internal platform-specific createThread implementation.
     182ThreadIdentifier createThreadInternal(ThreadFunction, void*, const char* threadName);
     183
     184// Called in the thread during initialization.
     185// Helpful for platforms where the thread name must be set from within the thread.
     186void setThreadNameInternal(const char* threadName);
     187
     188ThreadIdentifier currentThread();
     189bool isMainThread();
     190int waitForThreadCompletion(ThreadIdentifier, void**);
     191void detachThread(ThreadIdentifier);
     192
    157193class Mutex : Noncopyable {
    158194public:

  • trunk/JavaScriptCore/wtf/ThreadingNone.cpp

    r41605 r43366  
    3333namespace WTF {
    3434
     35bool ThreadIdentifier::operator==(const ThreadIdentifier&) const { return true; }
     36bool ThreadIdentifier::operator!=(const ThreadIdentifier&) const { return false; }
     37
    3538void initializeThreading() { }
    3639ThreadIdentifier createThreadInternal(ThreadFunction, void*, const char*) { return 0; }

  • trunk/JavaScriptCore/wtf/ThreadingPthreads.cpp

    r42366 r43366  
    4949namespace WTF {
    5050
    51 typedef HashMap<ThreadIdentifier, pthread_t> ThreadMap;
     51bool ThreadIdentifier::operator==(const ThreadIdentifier& another) const
     52{
     53    return pthread_equal(m_platformId, another.m_platformId);
     54}
     55
     56bool ThreadIdentifier::operator!=(const ThreadIdentifier& another) const
     57{
     58    return !pthread_equal(m_platformId, another.m_platformId);
     59}
    5260
    5361static Mutex* atomicallyInitializedStaticMutex;
    … …  
    5765#endif
    5866
    59 static Mutex& threadMapMutex()
    60 {
    61     DEFINE_STATIC_LOCAL(Mutex, mutex, ());
    62     return mutex;
    63 }
    64 
    6567void initializeThreading()
    6668{
    6769    if (!atomicallyInitializedStaticMutex) {
    6870        atomicallyInitializedStaticMutex = new Mutex;
    69         threadMapMutex();
    7071        initializeRandomNumberGenerator();
    7172#if !PLATFORM(DARWIN) || PLATFORM(CHROMIUM)
    … …  
    8586{
    8687    atomicallyInitializedStaticMutex->unlock();
    87 }
    88 
    89 static ThreadMap& threadMap()
    90 {
    91     DEFINE_STATIC_LOCAL(ThreadMap, map, ());
    92     return map;
    93 }
    94 
    95 static ThreadIdentifier identifierByPthreadHandle(const pthread_t& pthreadHandle)
    96 {
    97     MutexLocker locker(threadMapMutex());
    98 
    99     ThreadMap::iterator i = threadMap().begin();
    100     for (; i != threadMap().end(); ++i) {
    101         if (pthread_equal(i->second, pthreadHandle))
    102             return i->first;
    103     }
    104 
    105     return 0;
    106 }
    107 
    108 static ThreadIdentifier establishIdentifierForPthreadHandle(pthread_t& pthreadHandle)
    109 {
    110     ASSERT(!identifierByPthreadHandle(pthreadHandle));
    111 
    112     MutexLocker locker(threadMapMutex());
    113 
    114     static ThreadIdentifier identifierCount = 1;
    115 
    116     threadMap().add(identifierCount, pthreadHandle);
    117    
    118     return identifierCount++;
    119 }
    120 
    121 static pthread_t pthreadHandleForIdentifier(ThreadIdentifier id)
    122 {
    123     MutexLocker locker(threadMapMutex());
    124    
    125     return threadMap().get(id);
    126 }
    127 
    128 static void clearPthreadHandleForIdentifier(ThreadIdentifier id)
    129 {
    130     MutexLocker locker(threadMapMutex());
    131 
    132     ASSERT(threadMap().contains(id));
    133    
    134     threadMap().remove(id);
    13588}
    13689
    … …  
    165118    if (pthread_create(&threadHandle, 0, runThreadWithRegistration, static_cast<void*>(threadData))) {
    166119        LOG_ERROR("Failed to create pthread at entry point %p with data %p", entryPoint, data);
    167         return 0;
    168     }
    169     return establishIdentifierForPthreadHandle(threadHandle);
     120        return ThreadIdentifier();
     121    }
     122    return ThreadIdentifier(threadHandle);
    170123}
    171124#else
    … …  
    175128    if (pthread_create(&threadHandle, 0, entryPoint, data)) {
    176129        LOG_ERROR("Failed to create pthread at entry point %p with data %p", entryPoint, data);
    177         return 0;
    178     }
    179 
    180     return establishIdentifierForPthreadHandle(threadHandle);
     130        return ThreadIdentifier();
     131    }
     132
     133    return ThreadIdentifier(threadHandle);
    181134}
    182135#endif
    … …  
    193146int waitForThreadCompletion(ThreadIdentifier threadID, void** result)
    194147{
    195     ASSERT(threadID);
    196    
    197     pthread_t pthreadHandle = pthreadHandleForIdentifier(threadID);
     148    ASSERT(threadID.isValid());
     149   
     150    pthread_t pthreadHandle = threadID.platformId();
    198151 
    199152    int joinResult = pthread_join(pthreadHandle, result);
    200153    if (joinResult == EDEADLK)
    201         LOG_ERROR("ThreadIdentifier %u was found to be deadlocked trying to quit", threadID);
     154        LOG_ERROR("ThreadIdentifier %p was found to be deadlocked trying to quit", pthreadHandle);
    202155       
    203     clearPthreadHandleForIdentifier(threadID);
    204156    return joinResult;
    205157}
    … …  
    207159void detachThread(ThreadIdentifier threadID)
    208160{
    209     ASSERT(threadID);
    210    
    211     pthread_t pthreadHandle = pthreadHandleForIdentifier(threadID);
     161    ASSERT(threadID.isValid());
     162   
     163    pthread_t pthreadHandle = threadID.platformId();
    212164   
    213165    pthread_detach(pthreadHandle);
    214    
    215     clearPthreadHandleForIdentifier(threadID);
    216166}
    217167
    218168ThreadIdentifier currentThread()
    219169{
    220     pthread_t currentThread = pthread_self();
    221     if (ThreadIdentifier id = identifierByPthreadHandle(currentThread))
    222         return id;
    223     return establishIdentifierForPthreadHandle(currentThread);
     170    return ThreadIdentifier(pthread_self());
    224171}
    225172

  • trunk/JavaScriptCore/wtf/ThreadingWin.cpp

    r41626 r43366  
    9999namespace WTF {
    100100
     101bool ThreadIdentifier::operator==(const ThreadIdentifier& another) const
     102{
     103    return m_platformId == another.m_platformId;
     104}
     105
     106bool ThreadIdentifier::operator!=(const ThreadIdentifier& another) const
     107{
     108    return m_platformId != another.m_platformId;
     109}
     110
    101111// MS_VC_EXCEPTION, THREADNAME_INFO, and setThreadNameInternal all come from <http://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx>.
    102112static const DWORD MS_VC_EXCEPTION = 0x406D1388;
    … …  
    140150static ThreadIdentifier mainThreadIdentifier;
    141151
    142 static Mutex& threadMapMutex()
    143 {
    144     static Mutex mutex;
    145     return mutex;
    146 }
    147 
    148152void initializeThreading()
    149153{
    150154    if (!atomicallyInitializedStaticMutex) {
    151155        atomicallyInitializedStaticMutex = new Mutex;
    152         threadMapMutex();
    153156        initializeRandomNumberGenerator();
    154157        initializeMainThread();
    … …  
    158161}
    159162
    160 static HashMap<DWORD, HANDLE>& threadMap()
    161 {
    162     static HashMap<DWORD, HANDLE> map;
    163     return map;
    164 }
    165 
    166 static void storeThreadHandleByIdentifier(DWORD threadID, HANDLE threadHandle)
    167 {
    168     MutexLocker locker(threadMapMutex());
    169     ASSERT(!threadMap().contains(threadID));
    170     threadMap().add(threadID, threadHandle);
    171 }
    172 
    173 static HANDLE threadHandleForIdentifier(ThreadIdentifier id)
    174 {
    175     MutexLocker locker(threadMapMutex());
    176     return threadMap().get(id);
    177 }
    178 
    179 static void clearThreadHandleForIdentifier(ThreadIdentifier id)
    180 {
    181     MutexLocker locker(threadMapMutex());
    182     ASSERT(threadMap().contains(id));
    183     threadMap().remove(id);
    184 }
    185 
    186163struct ThreadFunctionInvocation {
    187164    ThreadFunctionInvocation(ThreadFunction function, void* data) : function(function), data(data) {}
    … …  
    209186{
    210187    unsigned threadIdentifier = 0;
    211     ThreadIdentifier threadID = 0;
    212188    ThreadFunctionInvocation* invocation = new ThreadFunctionInvocation(entryPoint, data);
    213189    HANDLE threadHandle = reinterpret_cast<HANDLE>(_beginthreadex(0, 0, wtfThreadEntryPoint, invocation, 0, &threadIdentifier));
    214190    if (!threadHandle) {
    215191        LOG_ERROR("Failed to create thread at entry point %p with data %p: %ld", entryPoint, data, errno);
    216         return 0;
    217     }
    218 
    219     threadID = static_cast<ThreadIdentifier>(threadIdentifier);
    220     storeThreadHandleByIdentifier(threadIdentifier, threadHandle);
    221 
    222     return threadID;
     192        return ThreadIdentifier();
     193    }
     194    // Closes handle only, since we don't need it. The new thread runs until it exits.
     195    CloseHandle(threadHandle);
     196
     197    return ThreadIdentifier(threadIdentifier);
    223198}
    224199
    225200int waitForThreadCompletion(ThreadIdentifier threadID, void** result)
    226201{
    227     ASSERT(threadID);
     202    ASSERT(threadID.isValid());
    228203   
    229     HANDLE threadHandle = threadHandleForIdentifier(threadID);
     204    unsigned threadIdentifier = threadID.platformId();
     205    HANDLE threadHandle = OpenThread(SYNCHRONIZE, FALSE, threadIdentifier);
     206    // If thread already exited, return immediately.
    230207    if (!threadHandle)
    231         LOG_ERROR("ThreadIdentifier %u did not correspond to an active thread when trying to quit", threadID);
     208        return WAIT_OBJECT_0;
    232209 
    233210    DWORD joinResult = WaitForSingleObject(threadHandle, INFINITE);
    234211    if (joinResult == WAIT_FAILED)
    235         LOG_ERROR("ThreadIdentifier %u was found to be deadlocked trying to quit", threadID);
     212        LOG_ERROR("ThreadIdentifier %p was found to be deadlocked trying to quit", threadHandle);
    236213
    237214    CloseHandle(threadHandle);
    238     clearThreadHandleForIdentifier(threadID);
    239215
    240216    return joinResult;
    241217}
    242218
    243 void detachThread(ThreadIdentifier threadID)
    244 {
    245     ASSERT(threadID);
    246    
    247     HANDLE threadHandle = threadHandleForIdentifier(threadID);
    248     if (threadHandle)
    249         CloseHandle(threadHandle);
    250     clearThreadHandleForIdentifier(threadID);
     219void detachThread(ThreadIdentifier)
     220{
    251221}
    252222
    253223ThreadIdentifier currentThread()
    254224{
    255     return static_cast<ThreadIdentifier>(GetCurrentThreadId());
     225    return ThreadIdentifier(GetCurrentThreadId());
    256226}
    257227
    … …  
    471441}
    472442
     443// Deprecated functions. The current build of Safari 4 beta is linked with them so we need to provide
     444// the implementation taking PlatformThreadIdentifier instead of ThreadIdentifier. These are not declared
     445// in .h file so the next time Safari is built it will 'automatically' switch to new functions.
     446// Then deprecated ones can be removed from this file and from JavaScriptCore.def and WebKit.def files.
     447// In WebKit.def file, these functions are 'renamed' so their name does not have 'Deprecated' part - this
     448// is to avoid having 2 functions with only different type of return value.
     449void detachThreadDeprecated(PlatformThreadIdentifier)
     450{
     451}
     452
     453int waitForThreadCompletionDeprecated(PlatformThreadIdentifier threadID, void** result)
     454{
     455    ASSERT(threadID);
     456
     457    unsigned threadIdentifier = static_cast<unsigned>(threadID);
     458    HANDLE threadHandle = OpenThread(SYNCHRONIZE, FALSE, threadIdentifier);
     459    // If thread already exited, return immediately.
     460    if (!threadHandle)
     461        return WAIT_OBJECT_0;
     462
     463    DWORD joinResult = WaitForSingleObject(threadHandle, INFINITE);
     464    if (joinResult == WAIT_FAILED)
     465        LOG_ERROR("ThreadIdentifier %p was found to be deadlocked trying to quit", threadHandle);
     466
     467    CloseHandle(threadHandle);
     468
     469    return joinResult;
     470}
     471
     472PlatformThreadIdentifier currentThreadDeprecated()
     473{
     474    return static_cast<PlatformThreadIdentifier>(GetCurrentThreadId());
     475}
     476
     477PlatformThreadIdentifier createThreadDeprecated(ThreadFunction entryPoint, void* data, const char* name)
     478{
     479    ThreadIdentifier threadID = createThread(entryPoint, data, name);
     480    return static_cast<PlatformThreadIdentifier>(threadID.platformId());
     481}
     482
    473483} // namespace WTF

  • trunk/JavaScriptCore/wtf/gtk/ThreadingGtk.cpp

    r42857 r43366  
    4343namespace WTF {
    4444
     45bool ThreadIdentifier::operator==(const ThreadIdentifier& another) const
     46{
     47    return m_platformId == another.m_platformId;
     48}
     49
     50bool ThreadIdentifier::operator!=(const ThreadIdentifier& another) const
     51{
     52    return m_platformId != another.m_platformId;
     53}
     54
    4555static Mutex* atomicallyInitializedStaticMutex;
    4656
    4757static ThreadIdentifier mainThreadIdentifier;
    48 
    49 static Mutex& threadMapMutex()
    50 {
    51     static Mutex mutex;
    52     return mutex;
    53 }
    5458
    5559void initializeThreading()
    … …  
    6165    if (!atomicallyInitializedStaticMutex) {
    6266        atomicallyInitializedStaticMutex = new Mutex;
    63         threadMapMutex();
    6467        initializeRandomNumberGenerator();
    6568        mainThreadIdentifier = currentThread();
    … …  
    7982}
    8083
    81 static HashMap<ThreadIdentifier, GThread*>& threadMap()
    82 {
    83     static HashMap<ThreadIdentifier, GThread*> map;
    84     return map;
    85 }
    86 
    87 static ThreadIdentifier identifierByGthreadHandle(GThread*& thread)
    88 {
    89     MutexLocker locker(threadMapMutex());
    90 
    91     HashMap<ThreadIdentifier, GThread*>::iterator i = threadMap().begin();
    92     for (; i != threadMap().end(); ++i) {
    93         if (i->second == thread)
    94             return i->first;
    95     }
    96 
    97     return 0;
    98 }
    99 
    100 static ThreadIdentifier establishIdentifierForThread(GThread*& thread)
    101 {
    102     ASSERT(!identifierByGthreadHandle(thread));
    103 
    104     MutexLocker locker(threadMapMutex());
    105 
    106     static ThreadIdentifier identifierCount = 1;
    107 
    108     threadMap().add(identifierCount, thread);
    109 
    110     return identifierCount++;
    111 }
    112 
    113 static GThread* threadForIdentifier(ThreadIdentifier id)
    114 {
    115     MutexLocker locker(threadMapMutex());
    116 
    117     return threadMap().get(id);
    118 }
    119 
    120 static void clearThreadForIdentifier(ThreadIdentifier id)
    121 {
    122     MutexLocker locker(threadMapMutex());
    123 
    124     ASSERT(threadMap().contains(id));
    125 
    126     threadMap().remove(id);
    127 }
    128 
    12984ThreadIdentifier createThreadInternal(ThreadFunction entryPoint, void* data, const char*)
    13085{
    … …  
    13287    if (!(thread = g_thread_create(entryPoint, data, TRUE, 0))) {
    13388        LOG_ERROR("Failed to create thread at entry point %p with data %p", entryPoint, data);
    134         return 0;
     89        return ThreadIdentifier();
    13590    }
    13691
    137     ThreadIdentifier threadID = establishIdentifierForThread(thread);
    138     return threadID;
     92    return ThreadIdentifier(thread);
    13993}
    14094
    … …  
    14599int waitForThreadCompletion(ThreadIdentifier threadID, void** result)
    146100{
    147     ASSERT(threadID);
     101    ASSERT(threadID.isValid());
    148102
    149     GThread* thread = threadForIdentifier(threadID);
     103    GThread* thread = threadID.platformId();
    150104
    151105    void* joinResult = g_thread_join(thread);
    … …  
    153107        *result = joinResult;
    154108
    155     clearThreadForIdentifier(threadID);
    156109    return 0;
    157110}
    … …  
    163116ThreadIdentifier currentThread()
    164117{
    165     GThread* currentThread = g_thread_self();
    166     if (ThreadIdentifier id = identifierByGthreadHandle(currentThread))
    167         return id;
    168     return establishIdentifierForThread(currentThread);
     118    return ThreadIdentifier(g_thread_self());
    169119}
    170120

  • trunk/JavaScriptCore/wtf/qt/ThreadingQt.cpp

    r42858 r43366  
    4242namespace WTF {
    4343
     44bool ThreadIdentifier::operator==(const ThreadIdentifier& another) const
     45{
     46    return m_platformId == another.m_platformId;
     47}
     48
     49bool ThreadIdentifier::operator!=(const ThreadIdentifier& another) const
     50{
     51    return m_platformId != another.m_platformId;
     52}
     53
    4454class ThreadPrivate : public QThread {
    4555public:
    … …  
    7080static ThreadIdentifier mainThreadIdentifier;
    7181
    72 static Mutex& threadMapMutex()
    73 {
    74     static Mutex mutex;
    75     return mutex;
    76 }
    77 
    78 static HashMap<ThreadIdentifier, QThread*>& threadMap()
    79 {
    80     static HashMap<ThreadIdentifier, QThread*> map;
    81     return map;
    82 }
    83 
    84 static ThreadIdentifier identifierByQthreadHandle(QThread*& thread)
    85 {
    86     MutexLocker locker(threadMapMutex());
    87 
    88     HashMap<ThreadIdentifier, QThread*>::iterator i = threadMap().begin();
    89     for (; i != threadMap().end(); ++i) {
    90         if (i->second == thread)
    91             return i->first;
    92     }
    93 
    94     return 0;
    95 }
    96 
    97 static ThreadIdentifier establishIdentifierForThread(QThread*& thread)
    98 {
    99     ASSERT(!identifierByQthreadHandle(thread));
    100 
    101     MutexLocker locker(threadMapMutex());
    102 
    103     static ThreadIdentifier identifierCount = 1;
    104 
    105     threadMap().add(identifierCount, thread);
    106 
    107     return identifierCount++;
    108 }
    109 
    110 static void clearThreadForIdentifier(ThreadIdentifier id)
    111 {
    112     MutexLocker locker(threadMapMutex());
    113 
    114     ASSERT(threadMap().contains(id));
    115 
    116     threadMap().remove(id);
    117 }
    118 
    119 static QThread* threadForIdentifier(ThreadIdentifier id)
    120 {
    121     MutexLocker locker(threadMapMutex());
    122 
    123     return threadMap().get(id);
    124 }
    125 
    12682void initializeThreading()
    12783{
    12884    if (!atomicallyInitializedStaticMutex) {
    12985        atomicallyInitializedStaticMutex = new Mutex;
    130         threadMapMutex();
    13186        initializeRandomNumberGenerator();
    132         QThread* mainThread = QCoreApplication::instance()->thread();
    133         mainThreadIdentifier = identifierByQthreadHandle(mainThread);
    134         if (!mainThreadIdentifier)
    135             mainThreadIdentifier = establishIdentifierForThread(mainThread);
     87        mainThreadIdentifier = ThreadIdentifier(QCoreApplication::instance()->thread());
    13688        initializeMainThread();
    13789    }
    … …  
    154106    if (!thread) {
    155107        LOG_ERROR("Failed to create thread at entry point %p with data %p", entryPoint, data);
    156         return 0;
     108        return ThreadIdentifier();
    157109    }
    158110    thread->start();
    … …  
    160112    QThread* threadRef = static_cast<QThread*>(thread);
    161113
    162     return establishIdentifierForThread(threadRef);
     114    return ThreadIdentifier(threadRef);
    163115}
    164116
    … …  
    169121int waitForThreadCompletion(ThreadIdentifier threadID, void** result)
    170122{
    171     ASSERT(threadID);
    172 
    173     QThread* thread = threadForIdentifier(threadID);
     123    ASSERT(threadID.IsValid());
     124
     125    QThread* thread = threadID.platformId();
    174126
    175127    bool res = thread->wait();
    176128
    177     clearThreadForIdentifier(threadID);
    178129    if (result)
    179130        *result = static_cast<ThreadPrivate*>(thread)->getReturnValue();
    … …  
    188139ThreadIdentifier currentThread()
    189140{
    190     QThread* currentThread = QThread::currentThread();
    191     if (ThreadIdentifier id = identifierByQthreadHandle(currentThread))
    192         return id;
    193     return establishIdentifierForThread(currentThread);
     141    return ThreadIdentifier(QThread::currentThread());
    194142}
    195143
Note: See TracChangeset for help on using the changeset viewer.