wtf/WTFThreadData.h

   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
  97     JSC::IdentifierTable* currentIdentifierTable()
  98     {
  99         return m_currentIdentifierTable;
 100     }
 101
 102     JSC::IdentifierTable* setCurrentIdentifierTable(JSC::IdentifierTable* identifierTable)
 103     {
 104         JSC::IdentifierTable* oldIdentifierTable = m_currentIdentifierTable;
 105         m_currentIdentifierTable = identifierTable;
 106         return oldIdentifierTable;
 107     }
 108
 109     void resetCurrentIdentifierTable()
 110     {
 111         m_currentIdentifierTable = m_defaultIdentifierTable;
 112     }
 113 #endif
 114
 115 private:
 116     WebCore::AtomicStringTable* m_atomicStringTable;
 117     AtomicStringTableDestructor m_atomicStringTableDestructor;
 118
 119 #if USE(JSC)
 120     JSC::IdentifierTable* m_defaultIdentifierTable;
 121     JSC::IdentifierTable* m_currentIdentifierTable;
 122 #endif
 123
 124 #if WTFTHREADDATA_MULTITHREADED
 125     static JS_EXPORTDATA ThreadSpecific<WTFThreadData>* staticData;
 126 #else
 127     static JS_EXPORTDATA WTFThreadData* staticData;
 128 #endif
 129     friend WTFThreadData& wtfThreadData();
 130     friend class WebCore::AtomicStringTable;
 131 };
 132
 133 inline WTFThreadData& wtfThreadData()
 134 {
 135 #if WTFTHREADDATA_MULTITHREADED
 136     // WRT WebCore:
 137     //    WTFThreadData is used on main thread before it could possibly be used
 138     //    on secondary ones, so there is no need for synchronization here.
 139     // WRT JavaScriptCore:
 140     //    wtfThreadData() is initially called from initializeThreading(), ensuring
 141     //    this is initially called in a pthread_once locked context.
 142     if (!WTFThreadData::staticData)
 143         WTFThreadData::staticData = new ThreadSpecific<WTFThreadData>;
 144     return **WTFThreadData::staticData;
 145 #else
 146     if (!WTFThreadData::staticData) {
 147         WTFThreadData::staticData = static_cast<WTFThreadData*>(fastMalloc(sizeof(WTFThreadData)));
 148         // WTFThreadData constructor indirectly uses staticData, so we need to set up the memory before invoking it.
 149         new (WTFThreadData::staticData) WTFThreadData;
 150     }
 151     return *WTFThreadData::staticData;
 152 #endif
 153 }
 154
 155 } // namespace WTF
 156
 157 using WTF::WTFThreadData;
 158 using WTF::wtfThreadData;
 159
 160 #endif // WTFThreadData_h