Changeset 58114 in webkit for trunk/JavaScriptCore/runtime/Identifier.cpp

Timestamp:

Apr 22, 2010, 1:31:04 PM (15 years ago)

Author:

[email protected]

Message:

​https://bugs.webkit.org/show_bug.cgi?id=37978
Unify JSC::IdentifierTable and WebCore::AtomicStringTable implementations.

Reviewed by Geoff Garen.

These two classes both implement a HashSet of uniqued StringImpls, with
translator classes to avoid unnecessary object creation. The only difference
between the classes is which flag (isIdentifier or inTable) is set.
Combine the two classes using a template predicated on which flag to use.

New class AtomicStringTable created, containing all the goodness from
IdentifierTable & AtomicStringTable, expect for Identifier's literalTable,
which has been moved onto JSGlobalData. Removed duplicate string translator
classes. Renamed StringImpl's inTable flag to more explicit 'isAtomic',
and set this on the empty string (which matches Identifier behaviour, and
removes a redundant check for zero-length).

• GNUmakefile.am:
• JavaScriptCore.gypi:
• JavaScriptCore.vcproj/WTF/WTF.vcproj:
• JavaScriptCore.xcodeproj/project.pbxproj:
• runtime/Identifier.cpp:

(JSC::createLiteralTable):
(JSC::deleteLiteralTable):
(JSC::Identifier::add):
(JSC::Identifier::addSlowCase):

• runtime/Identifier.h:
• runtime/JSGlobalData.cpp:

(JSC::JSGlobalData::JSGlobalData):
(JSC::JSGlobalData::~JSGlobalData):

• runtime/JSGlobalData.h:
• wtf/WTFThreadData.cpp:

(WTF::WTFThreadData::WTFThreadData):
(WTF::WTFThreadData::~WTFThreadData):

• wtf/WTFThreadData.h:

(WTF::WTFThreadData::atomicStringTable):

• wtf/text/AtomicString.cpp:

(WebCore::table):
(WebCore::operator==):
(WebCore::AtomicString::add):
(WebCore::AtomicString::find):
(WebCore::AtomicString::remove):

• wtf/text/AtomicStringTable.h: Added.

(WTF::CStringTranslator::hash):
(WTF::CStringTranslator::equal):
(WTF::CStringTranslator::translate):
(WTF::UCharBufferTranslator::hash):
(WTF::UCharBufferTranslator::equal):
(WTF::UCharBufferTranslator::translate):
(WTF::HashAndCharactersTranslator::hash):
(WTF::HashAndCharactersTranslator::equal):
(WTF::HashAndCharactersTranslator::translate):
(WTF::IdentifierOrAtomicStringTable::remove):
(WTF::::~IdentifierOrAtomicStringTable):
(WTF::::add):
(WTF::::find):

• wtf/text/StringImpl.cpp:

(WebCore::StringImpl::~StringImpl):

• wtf/text/StringImpl.h:

(WebCore::StringImpl::isAtomic):
(WebCore::StringImpl::setIsAtomic):
(WebCore::equal):

• wtf/text/StringImplBase.h:

(WTF::StringImplBase::StringImplBase):

File:

• trunk/JavaScriptCore/runtime/Identifier.cpp (modified) (7 diffs)

trunk/JavaScriptCore/runtime/Identifier.cpp

@@ -30 +30 @@
 #include <wtf/HashSet.h>
 #include <wtf/WTFThreadData.h>
+#include <wtf/text/AtomicStringTable.h>
 #include <wtf/text/StringHash.h>
 
@@ -36 +37 @@
 namespace JSC {
 
-IdentifierTable::~IdentifierTable()
+class LiteralTable : public HashMap<const char*, RefPtr<StringImpl>, PtrHash<const char*> > {};
+
+LiteralTable* createLiteralTable()
 {
-    HashSet<StringImpl*>::iterator end = m_table.end();
-    for (HashSet<StringImpl*>::iterator iter = m_table.begin(); iter != end; ++iter)
-        (*iter)->setIsIdentifier(false);
+    return new LiteralTable;
 }
-std::pair<HashSet<StringImpl*>::iterator, bool> IdentifierTable::add(StringImpl* value)
+
+void deleteLiteralTable(LiteralTable* table)
 {
-    std::pair<HashSet<StringImpl*>::iterator, bool> result = m_table.add(value);
-    (*result.first)->setIsIdentifier(true);
-    return result;
-}
-template<typename U, typename V>
-std::pair<HashSet<StringImpl*>::iterator, bool> IdentifierTable::add(U value)
-{
-    std::pair<HashSet<StringImpl*>::iterator, bool> result = m_table.add<U, V>(value);
-    (*result.first)->setIsIdentifier(true);
-    return result;
+    delete table;
 }
 
@@ -87 +80 @@
 }
 
-struct IdentifierCStringTranslator {
-    static unsigned hash(const char* c)
-    {
-        return UString::Rep::computeHash(c);
-    }
-
-    static bool equal(UString::Rep* r, const char* s)
-    {
-        return Identifier::equal(r, s);
-    }
-
-    static void translate(UString::Rep*& location, const char* c, unsigned hash)
-    {
-        size_t length = strlen(c);
-        UChar* d;
-        UString::Rep* r = UString::Rep::createUninitialized(length, d).releaseRef();
-        for (size_t i = 0; i != length; i++)
-            d[i] = static_cast<unsigned char>(c[i]); // use unsigned char to zero-extend instead of sign-extend
-        r->setHash(hash);
-        location = r;
-    }
-};
-
 PassRefPtr<UString::Rep> Identifier::add(JSGlobalData* globalData, const char* c)
 {
@@ -119 +89 @@
         return add(globalData, globalData->smallStrings.singleCharacterStringRep(static_cast<unsigned char>(c[0])));
 
-    IdentifierTable& identifierTable = *globalData->identifierTable;
-    LiteralIdentifierTable& literalIdentifierTable = identifierTable.literalTable();
+    LiteralTable* literalTable = globalData->literalTable;
+    pair<LiteralTable::iterator, bool> result = literalTable->add(c, 0);
+    if (!result.second) // pre-existing entry
+        return result.first->second;
 
-    const LiteralIdentifierTable::iterator& iter = literalIdentifierTable.find(c);
-    if (iter != literalIdentifierTable.end())
-        return iter->second;
-
-    pair<HashSet<UString::Rep*>::iterator, bool> addResult = identifierTable.add<const char*, IdentifierCStringTranslator>(c);
-
-    // If the string is newly-translated, then we need to adopt it.
-    // The boolean in the pair tells us if that is so.
-    RefPtr<UString::Rep> addedString = addResult.second ? adoptRef(*addResult.first) : *addResult.first;
-
-    literalIdentifierTable.add(c, addedString.get());
+    RefPtr<StringImpl> addedString = globalData->identifierTable->add(c);
+    result.first->second = addedString.get();
 
     return addedString.release();
@@ -141 +104 @@
     return add(&exec->globalData(), c);
 }
-
-struct UCharBuffer {
-    const UChar* s;
-    unsigned int length;
-};
-
-struct IdentifierUCharBufferTranslator {
-    static unsigned hash(const UCharBuffer& buf)
-    {
-        return UString::Rep::computeHash(buf.s, buf.length);
-    }
-
-    static bool equal(UString::Rep* str, const UCharBuffer& buf)
-    {
-        return Identifier::equal(str, buf.s, buf.length);
-    }
-
-    static void translate(UString::Rep*& location, const UCharBuffer& buf, unsigned hash)
-    {
-        UChar* d;
-        UString::Rep* r = UString::Rep::createUninitialized(buf.length, d).releaseRef();
-        for (unsigned i = 0; i != buf.length; i++)
-            d[i] = buf.s[i];
-        r->setHash(hash);
-        location = r; 
-    }
-};
 
 PassRefPtr<UString::Rep> Identifier::add(JSGlobalData* globalData, const UChar* s, int length)
@@ -178 +114 @@
     if (!length)
         return UString::Rep::empty();
-    UCharBuffer buf = {s, length}; 
-    pair<HashSet<UString::Rep*>::iterator, bool> addResult = globalData->identifierTable->add<UCharBuffer, IdentifierUCharBufferTranslator>(buf);
 
-    // If the string is newly-translated, then we need to adopt it.
-    // The boolean in the pair tells us if that is so.
-    return addResult.second ? adoptRef(*addResult.first) : *addResult.first;
+    return globalData->identifierTable->add(s, length);
 }
 
@@ -206 +138 @@
     }
 
-    return *globalData->identifierTable->add(r).first;
+    return globalData->identifierTable->add(r);
 }