1 /*

     2  * Copyright (C) 2008 Apple Inc. All Rights Reserved.

     3  *

     4  * Redistribution and use in source and binary forms, with or without

     5  * modification, are permitted provided that the following conditions

     6  * are met:

     7  * 1. Redistributions of source code must retain the above copyright

     8  *    notice, this list of conditions and the following disclaimer.

     9  * 2. Redistributions in binary form must reproduce the above copyright

    10  *    notice, this list of conditions and the following disclaimer in the

    11  *    documentation and/or other materials provided with the distribution.

    12  *

    13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY

    14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

    15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

    16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR

    17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

    18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

    19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

    20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

    21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

    23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

    24  *

    25  */

    26 

    27 #ifndef WTFThreadData_h

    28 #define WTFThreadData_h

    29 

    30 #include <wtf/HashMap.h>

    31 #include <wtf/HashSet.h>

    32 #include <wtf/Noncopyable.h>

    33 #include <wtf/text/StringHash.h>

    34 

    35 // This was ENABLE(WORKERS) in WebCore, but this is not defined when compiling JSC.

    36 // However this check was not correct anyway, re this comment:

    37 //    // FIXME: Workers are not necessarily the only feature that make per-thread global data necessary.

    38 //    // We need to check for e.g. database objects manipulating strings on secondary threads.

    39 // Always enabling this is safe, and should be a better option until we can come up

    40 // with a better define.

    41 #define WTFTHREADDATA_MULTITHREADED 1

    42 

    43 #if WTFTHREADDATA_MULTITHREADED

    44 #include <wtf/ThreadSpecific.h>

    45 #include <wtf/Threading.h>

    46 #endif

    47 

    48 // FIXME: This is a temporary layering violation while we move more string code to WTF.

    49 namespace WebCore {

    50 class AtomicStringTable;

    51 class StringImpl;

    52 }

    53 using WebCore::StringImpl;

    54 

    55 typedef void (*AtomicStringTableDestructor)(WebCore::AtomicStringTable*);

    56 

    57 #if USE(JSC)

    58 // FIXME: This is a temporary layering violation while we move more string code to WTF.

    59 namespace JSC {

    60 

    61 typedef HashMap<const char*, RefPtr<StringImpl>, PtrHash<const char*> > LiteralIdentifierTable;

    62 

    63 class IdentifierTable : public FastAllocBase {

    64 public:

    65     ~IdentifierTable();

    66 

    67     std::pair<HashSet<StringImpl*>::iterator, bool> add(StringImpl* value);

    68     template<typename U, typename V>

    69     std::pair<HashSet<StringImpl*>::iterator, bool> add(U value);

    70 

    71     void remove(StringImpl* r) { m_table.remove(r); }

    72 

    73     LiteralIdentifierTable& literalTable() { return m_literalTable; }

    74 

    75 private:

    76     HashSet<StringImpl*> m_table;

    77     LiteralIdentifierTable m_literalTable;

    78 };

    79 

    80 }

    81 #endif

    82 

    83 namespace WTF {

    84 

    85 class WTFThreadData : public Noncopyable {

    86 public:

    87     WTFThreadData();

    88     ~WTFThreadData();

    89 

    90     WebCore::AtomicStringTable* atomicStringTable()

    91     {

    92         return m_atomicStringTable;

    93     }

    94 

    95 #if USE(JSC)

    96     void initializeIdentifierTable(JSC::IdentifierTable* identifierTable)

    97     {

    98         m_defaultIdentifierTable = identifierTable;

    99         m_currentIdentifierTable = identifierTable;

   100     }

   101 

   102     JSC::IdentifierTable* currentIdentifierTable()

   103     {

   104         return m_currentIdentifierTable;

   105     }

   106 

   107     JSC::IdentifierTable* setCurrentIdentifierTable(JSC::IdentifierTable* identifierTable)

   108     {

   109         JSC::IdentifierTable* oldIdentifierTable = m_currentIdentifierTable;

   110         m_currentIdentifierTable = identifierTable;

   111         return oldIdentifierTable;

   112     }

   113 

   114     void resetCurrentIdentifierTable()

   115     {

   116         m_currentIdentifierTable = m_defaultIdentifierTable;

   117     }

   118 #endif

   119 

   120 private:

   121     WebCore::AtomicStringTable* m_atomicStringTable;

   122     AtomicStringTableDestructor m_atomicStringTableDestructor;

   123 

   124 #if USE(JSC)

   125     JSC::IdentifierTable* m_defaultIdentifierTable;

   126     JSC::IdentifierTable* m_currentIdentifierTable;

   127 #endif

   128 

   129 #if WTFTHREADDATA_MULTITHREADED

   130     static JS_EXPORTDATA ThreadSpecific<WTFThreadData>* staticData;

   131 #else

   132     static JS_EXPORTDATA WTFThreadData* staticData;

   133 #endif

   134     friend WTFThreadData& wtfThreadData();

   135     friend class WebCore::AtomicStringTable;

   136 };

   137 

   138 inline WTFThreadData& wtfThreadData()

   139 {

   140 #if WTFTHREADDATA_MULTITHREADED

   141     // WRT WebCore:

   142     //    WTFThreadData is used on main thread before it could possibly be used

   143     //    on secondary ones, so there is no need for synchronization here.

   144     // WRT JavaScriptCore:

   145     //    wtfThreadData() is initially called from initializeThreading(), ensuring

   146     //    this is initially called in a pthread_once locked context.

   147     if (!WTFThreadData::staticData)

   148         WTFThreadData::staticData = new ThreadSpecific<WTFThreadData>;

   149     return **WTFThreadData::staticData;

   150 #else

   151     if (!WTFThreadData::staticData) {

   152         WTFThreadData::staticData = static_cast<WTFThreadData*>(fastMalloc(sizeof(WTFThreadData)));

   153         // WTFThreadData constructor indirectly uses staticData, so we need to set up the memory before invoking it.

   154         new (WTFThreadData::staticData) WTFThreadData;

   155     }

   156     return *WTFThreadData::staticData;

   157 #endif

   158 }

   159 

   160 } // namespace WTF

   161 

   162 using WTF::WTFThreadData;

   163 using WTF::wtfThreadData;

   164 

   165 #endif // WTFThreadData_h