Changeset 257681 in webkit for trunk/Source/JavaScriptCore/builtins/BuiltinNames.cpp

Timestamp:

Feb 29, 2020, 12:04:13 AM (5 years ago)

Author:

[email protected]

Message:

[JSC] BuiltinNames' HashMap should be small
​https://bugs.webkit.org/show_bug.cgi?id=208404

Reviewed by Mark Lam.

Source/JavaScriptCore:

This patch converts public-to-private-name-map from HashMap<RefPtr<UniquedStringImpl>, SymbolImpl*> to HashSet<String> to save half of memory.
The key is that private names have the same string content to the public names. We can just query with string content to the HashSet of
private names, and we can get private names.

The problem is that we also have a hack inserting string <-> non-private well-known Symbol mappings into this table. These symbols do not have
the same content to the public string. So the above assumption is broken.

To make the above assumption valid, we have a separate small HashMap which holds string <-> non-private well-known Symbol mappings. Since # of
well-known Symbols are only 13, this new HashMap is taking at most 512B for entries, which is much smaller compared to the saved memory by
converting HashMap to HashSet for private names (32KB).

To allow it, we introduce new well-known Symbol identifier syntax to builtin JS, which is "@@iterator" format. If there is two "@", we parse this
identifier as a well-known Symbol.

• builtins/ArrayConstructor.js:

(from.wrapper.iterator):
(from):
(from.wrapper.iteratorSymbol): Deleted.

• builtins/ArrayPrototype.js:

(globalPrivate.concatSlowPath):
(concat):

• builtins/BuiltinNames.cpp:

(JSC::BuiltinNames::BuiltinNames):
(JSC::CharBufferSeacher::hash):
(JSC::CharBufferSeacher::equal):
(JSC::lookUpPrivateNameImpl):
(JSC::lookUpWellKnownSymbolImpl):
(JSC::BuiltinNames::lookUpPrivateName const):
(JSC::BuiltinNames::lookUpWellKnownSymbol const):

• builtins/BuiltinNames.h:

(JSC::BuiltinNames::lookUpPrivateName const):
(JSC::BuiltinNames::lookUpWellKnownSymbol const):
(JSC::BuiltinNames::checkPublicToPrivateMapConsistency):
(JSC::BuiltinNames::appendExternalName):
(JSC::BuiltinNames::getPublicName const): Deleted.

• builtins/GlobalOperations.js:

(globalPrivate.speciesConstructor):

• builtins/IteratorHelpers.js:

(performIteration):

• builtins/StringPrototype.js:

(match):
(matchAll):
(intrinsic.StringPrototypeReplaceIntrinsic.replace):
(replaceAll):
(search):
(split):

• builtins/TypedArrayConstructor.js:

(from.wrapper.iterator):
(from):
(from.wrapper.iteratorSymbol): Deleted.

• builtins/TypedArrayPrototype.js:

(globalPrivate.typedArraySpeciesConstructor):
(map):
(filter):

• bytecompiler/NodesCodegen.cpp:

(JSC::BytecodeIntrinsicNode::emit_intrinsic_getByIdDirectPrivate):
(JSC::BytecodeIntrinsicNode::emit_intrinsic_putByIdDirectPrivate):

• parser/Lexer.cpp:

(JSC::Lexer<LChar>::parseIdentifier):
(JSC::Lexer<UChar>::parseIdentifier):

• runtime/CachedTypes.cpp:

(JSC::CachedUniquedStringImplBase::encode):
(JSC::CachedUniquedStringImplBase::decode const):

• runtime/CommonIdentifiers.cpp:

(JSC::CommonIdentifiers::CommonIdentifiers):
(JSC::CommonIdentifiers::lookUpPrivateName const): Deleted.
(JSC::CommonIdentifiers::getPublicName const): Deleted.

• runtime/CommonIdentifiers.h:
• tools/JSDollarVM.cpp:

(JSC::functionGetPrivateProperty):

Source/WTF:

• wtf/text/AtomStringImpl.cpp:

(WTF::HashTranslatorCharBuffer::HashTranslatorCharBuffer): Deleted.

• wtf/text/StringImpl.h:

(WTF::HashTranslatorCharBuffer::HashTranslatorCharBuffer):

File:

• trunk/Source/JavaScriptCore/builtins/BuiltinNames.cpp (modified) (3 diffs)

trunk/Source/JavaScriptCore/builtins/BuiltinNames.cpp

@@ -53 +53 @@
 
 #define INITIALIZE_BUILTIN_NAMES_IN_JSC(name) , m_##name(JSC::Identifier::fromString(vm, #name))
-#define INITIALIZE_BUILTIN_SYMBOLS_IN_JSC(name) , m_##name##Symbol(JSC::Identifier::fromUid(vm, &static_cast<SymbolImpl&>(JSC::Symbols::name##Symbol))), m_##name##SymbolPrivateIdentifier(JSC::Identifier::fromString(vm, #name "Symbol"))
+#define INITIALIZE_BUILTIN_SYMBOLS_IN_JSC(name) \
+    , m_##name##Symbol(JSC::Identifier::fromUid(vm, &static_cast<SymbolImpl&>(JSC::Symbols::name##Symbol))) \
+    , m_##name##SymbolPrivateIdentifier(JSC::Identifier::fromString(vm, #name))
 
 #define INITIALIZE_PUBLIC_TO_PRIVATE_ENTRY(name) \
     do { \
         SymbolImpl* symbol = &static_cast<SymbolImpl&>(JSC::Symbols::name##PrivateName); \
-        checkPublicToPrivateMapConsistency(m_##name.impl(), symbol); \
-        m_publicToPrivateMap.add(m_##name.impl(), symbol); \
+        checkPublicToPrivateMapConsistency(symbol); \
+        m_privateNameSet.add(symbol); \
     } while (0);
 
-// We commandeer the publicToPrivateMap to allow us to convert private symbol names into the appropriate symbol.
-// e.g. @iteratorSymbol points to Symbol.iterator in this map rather than to a an actual private name.
-// FIXME: This is a weird hack and we shouldn't need to do this.
-#define INITIALIZE_SYMBOL_PUBLIC_TO_PRIVATE_ENTRY(name) \
+#define INITIALIZE_WELL_KNOWN_SYMBOL_PUBLIC_TO_PRIVATE_ENTRY(name) \
     do { \
         SymbolImpl* symbol = static_cast<SymbolImpl*>(m_##name##Symbol.impl()); \
-        checkPublicToPrivateMapConsistency(m_##name##SymbolPrivateIdentifier.impl(), symbol); \
-        m_publicToPrivateMap.add(m_##name##SymbolPrivateIdentifier.impl(), symbol); \
+        m_wellKnownSymbolsMap.add(m_##name##SymbolPrivateIdentifier.impl(), symbol); \
     } while (0);
 
@@ -85 +83 @@
     JSC_FOREACH_BUILTIN_FUNCTION_NAME(INITIALIZE_PUBLIC_TO_PRIVATE_ENTRY)
     JSC_COMMON_PRIVATE_IDENTIFIERS_EACH_PROPERTY_NAME(INITIALIZE_PUBLIC_TO_PRIVATE_ENTRY)
-    JSC_COMMON_PRIVATE_IDENTIFIERS_EACH_WELL_KNOWN_SYMBOL(INITIALIZE_SYMBOL_PUBLIC_TO_PRIVATE_ENTRY)
-    m_publicToPrivateMap.add(m_dollarVMName.impl(), static_cast<SymbolImpl*>(m_dollarVMPrivateName.impl()));
+    JSC_COMMON_PRIVATE_IDENTIFIERS_EACH_WELL_KNOWN_SYMBOL(INITIALIZE_WELL_KNOWN_SYMBOL_PUBLIC_TO_PRIVATE_ENTRY)
+    m_privateNameSet.add(static_cast<SymbolImpl*>(m_dollarVMPrivateName.impl()));
 }
 
@@ -92 +90 @@
 #undef INITIALIZE_BUILTIN_SYMBOLS_IN_JSC
 #undef INITIALIZE_PUBLIC_TO_PRIVATE_ENTRY
-#undef INITIALIZE_SYMBOL_PUBLIC_TO_PRIVATE_ENTRY
+#undef INITIALIZE_WELL_KNOWN_SYMBOL_PUBLIC_TO_PRIVATE_ENTRY
+
+
+using LCharBuffer = WTF::HashTranslatorCharBuffer<LChar>;
+using UCharBuffer = WTF::HashTranslatorCharBuffer<UChar>;
+
+template<typename CharacterType>
+struct CharBufferSeacher {
+    using Buffer = WTF::HashTranslatorCharBuffer<CharacterType>;
+    static unsigned hash(const Buffer& buf)
+    {
+        return buf.hash;
+    }
+
+    static bool equal(const String& str, const Buffer& buf)
+    {
+        return WTF::equal(str.impl(), buf.characters, buf.length);
+    }
+};
+
+template<typename CharacterType>
+static PrivateSymbolImpl* lookUpPrivateNameImpl(const HashSet<String>& set, const WTF::HashTranslatorCharBuffer<CharacterType>& buffer)
+{
+    auto iterator = set.find<CharBufferSeacher<CharacterType>>(buffer);
+    if (iterator == set.end())
+        return nullptr;
+    StringImpl* impl = iterator->impl();
+    ASSERT(impl->isSymbol());
+    SymbolImpl* symbol = static_cast<SymbolImpl*>(impl);
+    ASSERT(symbol->isPrivate());
+    return static_cast<PrivateSymbolImpl*>(symbol);
+}
+
+template<typename CharacterType>
+static SymbolImpl* lookUpWellKnownSymbolImpl(const HashMap<String, SymbolImpl*>& map, const WTF::HashTranslatorCharBuffer<CharacterType>& buffer)
+{
+    auto iterator = map.find<CharBufferSeacher<CharacterType>>(buffer);
+    if (iterator == map.end())
+        return nullptr;
+    return iterator->value;
+}
+
+PrivateSymbolImpl* BuiltinNames::lookUpPrivateName(const LChar* characters, unsigned length) const
+{
+    LCharBuffer buffer { characters, length };
+    return lookUpPrivateNameImpl(m_privateNameSet, buffer);
+}
+
+PrivateSymbolImpl* BuiltinNames::lookUpPrivateName(const UChar* characters, unsigned length) const
+{
+    UCharBuffer buffer { characters, length };
+    return lookUpPrivateNameImpl(m_privateNameSet, buffer);
+}
+
+PrivateSymbolImpl* BuiltinNames::lookUpPrivateName(const String& string) const
+{
+    if (string.is8Bit()) {
+        LCharBuffer buffer { string.characters8(), string.length(), string.hash() };
+        return lookUpPrivateNameImpl(m_privateNameSet, buffer);
+    }
+    UCharBuffer buffer { string.characters16(), string.length(), string.hash() };
+    return lookUpPrivateNameImpl(m_privateNameSet, buffer);
+}
+
+SymbolImpl* BuiltinNames::lookUpWellKnownSymbol(const LChar* characters, unsigned length) const
+{
+    LCharBuffer buffer { characters, length };
+    return lookUpWellKnownSymbolImpl(m_wellKnownSymbolsMap, buffer);
+}
+
+SymbolImpl* BuiltinNames::lookUpWellKnownSymbol(const UChar* characters, unsigned length) const
+{
+    UCharBuffer buffer { characters, length };
+    return lookUpWellKnownSymbolImpl(m_wellKnownSymbolsMap, buffer);
+}
+
+SymbolImpl* BuiltinNames::lookUpWellKnownSymbol(const String& string) const
+{
+    if (string.is8Bit()) {
+        LCharBuffer buffer { string.characters8(), string.length(), string.hash() };
+        return lookUpWellKnownSymbolImpl(m_wellKnownSymbolsMap, buffer);
+    }
+    UCharBuffer buffer { string.characters16(), string.length(), string.hash() };
+    return lookUpWellKnownSymbolImpl(m_wellKnownSymbolsMap, buffer);
+}
 
 } // namespace JSC