Changeset 165603 in webkit for trunk/Source/JavaScriptCore/runtime/JSObject.cpp

Timestamp:

Mar 13, 2014, 11:45:39 PM (11 years ago)

Author:

[email protected]

Message:

Reduce memory use for static property maps
​https://bugs.webkit.org/show_bug.cgi?id=129986

Reviewed by Andreas Kling.

Static property tables are currently duplicated on first use from read-only memory into dirty memory
in every process, and since the entries are large (48 bytes) and the tables can be unusually sparse
(we use a custom hash table without a rehash) a lot of memory may be wasted.

Source/JavaScriptCore:

First, reduce the size of the hashtable. Instead of storing values in the table the hashtable maps
from string hashes to indicies into a densely packed array of values. Compute the index table at
compile time as a part of the derived sources step, such that this may be read-only data.

Second, don't copy all data from the HashTableValue array into a HashEntry objects. Instead refer
directly to the HashTableValue entries. The only data that needs to be allocated at runtime are the
keys, which are Identifiers.

• create_hash_table:
  • emit the hash table index into the derived source (we were calculating this already to ensure chaining does not get too deep).
• parser/Lexer.cpp:

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

• HashEntry -> HashTableValue.

• parser/Lexer.h:

(JSC::Keywords::getKeyword):

• HashEntry -> HashTableValue.

• runtime/ClassInfo.h:
  • removed HashEntry.
• runtime/JSObject.cpp:

(JSC::getClassPropertyNames):

• use HashTable::ConstIterator.

(JSC::JSObject::put):
(JSC::JSObject::deleteProperty):
(JSC::JSObject::findPropertyHashEntry):

• HashEntry -> HashTableValue.

(JSC::JSObject::reifyStaticFunctionsForDelete):

• changed HashTable::ConstIterator interface.

• runtime/JSObject.h:
  • HashEntry -> HashTableValue.
• runtime/Lookup.cpp:

(JSC::HashTable::createTable):

• table -> keys, keys array is now densely packed.

(JSC::HashTable::deleteTable):

• table -> keys.

(JSC::setUpStaticFunctionSlot):

• HashEntry -> HashTableValue.

• runtime/Lookup.h:

(JSC::HashTableValue::builtinGenerator):
(JSC::HashTableValue::function):
(JSC::HashTableValue::functionLength):
(JSC::HashTableValue::propertyGetter):
(JSC::HashTableValue::propertyPutter):
(JSC::HashTableValue::lexerValue):

• added accessor methods from HashEntry.

(JSC::HashTable::copy):

• fields changed.

(JSC::HashTable::initializeIfNeeded):

• table -> keys.

(JSC::HashTable::entry):

• HashEntry -> HashTableValue.

(JSC::HashTable::ConstIterator::ConstIterator):

• iterate packed value array, so no need to skipInvalidKeys().

(JSC::HashTable::ConstIterator::value):
(JSC::HashTable::ConstIterator::key):
(JSC::HashTable::ConstIterator::operator->):

• accessors now get HashTableValue/StringImpl* separately.

(JSC::HashTable::ConstIterator::operator++):

• iterate packed value array, so no need to skipInvalidKeys().

(JSC::HashTable::end):

• end is now size of dense not sparse array.

(JSC::getStaticPropertySlot):
(JSC::getStaticFunctionSlot):
(JSC::getStaticValueSlot):
(JSC::putEntry):
(JSC::lookupPut):

• HashEntry -> HashTableValue.

Source/WebCore:

• bindings/js/JSDOMBinding.h:

(WebCore::getStaticValueSlotEntryWithoutCaching):
(WebCore::getStaticValueSlotEntryWithoutCaching<JSDOMWrapper>):

• HashEntry -> HashTableValue.

• bindings/js/JSDOMWindowCustom.cpp:

(WebCore::JSDOMWindow::getOwnPropertySlot):

• HashEntry -> HashTableValue.

• bindings/js/JSHistoryCustom.cpp:

(WebCore::JSHistory::getOwnPropertySlotDelegate):

• HashEntry -> HashTableValue.

• bindings/js/JSLocationCustom.cpp:

(WebCore::JSLocation::getOwnPropertySlotDelegate):
(WebCore::JSLocation::putDelegate):

• HashEntry -> HashTableValue.

• bindings/scripts/CodeGeneratorJS.pm:

(GenerateGetOwnPropertySlotBody):

• HashEntry -> HashTableValue.

(GenerateHashTable):

• emit the hash table index into the derived source (we were calculating this already to ensure chaining does not get too deep).

LayoutTests:

• inspector-protocol/debugger/setPauseOnExceptions-all-expected.txt:
• inspector-protocol/debugger/setPauseOnExceptions-none-expected.txt:
• inspector-protocol/debugger/setPauseOnExceptions-uncaught-expected.txt:
• js/dom/dom-static-property-for-in-iteration-expected.txt:
  • Properties now iterated in correct order, not permuted by hash table.

File:

• trunk/Source/JavaScriptCore/runtime/JSObject.cpp (modified) (5 diffs)

trunk/Source/JavaScriptCore/runtime/JSObject.cpp

@@ -76 +76 @@
 static inline void getClassPropertyNames(ExecState* exec, const ClassInfo* classInfo, PropertyNameArray& propertyNames, EnumerationMode mode, bool didReify)
 {
+    VM& vm = exec->vm();
+
     // Add properties from the static hashtables of properties
     for (; classInfo; classInfo = classInfo->parentClass) {
-        const HashTable* table = classInfo->propHashTable(exec);
+        const HashTable* table = classInfo->propHashTable(vm);
         if (!table)
             continue;
-        table->initializeIfNeeded(exec);
-        ASSERT(table->table);
-
-        int hashSizeMask = table->compactSize - 1;
-        const HashEntry* entry = table->table;
-        for (int i = 0; i <= hashSizeMask; ++i, ++entry) {
-            if (entry->key() && (!(entry->attributes() & DontEnum) || (mode == IncludeDontEnumProperties)) && !((entry->attributes() & BuiltinOrFunction) && didReify))
-                propertyNames.add(entry->key());
+
+        for (auto iter = table->begin(vm); iter != table->end(vm); ++iter) {
+            if ((!(iter->attributes() & DontEnum) || (mode == IncludeDontEnumProperties)) && !((iter->attributes() & BuiltinOrFunction) && didReify))
+                propertyNames.add(iter.key());
         }
     }
@@ -397 +395 @@
         const ClassInfo* info = obj->classInfo();
         if (info->hasStaticSetterOrReadonlyProperties(vm)) {
-            if (const HashEntry* entry = obj->findPropertyHashEntry(vm, propertyName)) {
+            if (const HashTableValue* entry = obj->findPropertyHashEntry(vm, propertyName)) {
                 putEntry(exec, entry, obj, propertyName, value, slot);
                 return;
@@ -1274 +1272 @@
 
     // Look in the static hashtable of properties
-    const HashEntry* entry = thisObject->findPropertyHashEntry(vm, propertyName);
+    const HashTableValue* entry = thisObject->findPropertyHashEntry(vm, propertyName);
     if (entry) {
         if (entry->attributes() & DontDelete && !vm.isInDefineOwnProperty())
@@ -1402 +1400 @@
 }
 
-const HashEntry* JSObject::findPropertyHashEntry(VM& vm, PropertyName propertyName) const
+const HashTableValue* JSObject::findPropertyHashEntry(VM& vm, PropertyName propertyName) const
 {
     for (const ClassInfo* info = classInfo(); info; info = info->parentClass) {
         if (const HashTable* propHashTable = info->propHashTable(vm)) {
-            if (const HashEntry* entry = propHashTable->entry(vm, propertyName))
+            if (const HashTableValue* entry = propHashTable->entry(vm, propertyName))
                 return entry;
         }
@@ -1622 +1620 @@
 
     for (const ClassInfo* info = classInfo(); info; info = info->parentClass) {
-        const HashTable* hashTable = info->propHashTable(globalObject()->globalExec());
+        const HashTable* hashTable = info->propHashTable(vm);
         if (!hashTable)
             continue;
         PropertySlot slot(this);
-        for (HashTable::ConstIterator iter = hashTable->begin(vm); iter != hashTable->end(vm); ++iter) {
+        for (auto iter = hashTable->begin(vm); iter != hashTable->end(vm); ++iter) {
             if (iter->attributes() & BuiltinOrFunction)
-                setUpStaticFunctionSlot(globalObject()->globalExec(), *iter, this, Identifier(&vm, iter->key()), slot);
+                setUpStaticFunctionSlot(globalObject()->globalExec(), iter.value(), this, Identifier(&vm, iter.key()), slot);
         }
     }