Changeset 29943 in webkit for trunk/JavaScriptCore/kjs/property_map.cpp

Timestamp:

Feb 2, 2008, 4:20:34 PM (17 years ago)

Author:

[email protected]

Message:

JavaScriptCore:

Reviewed by Geoff Garen.

PLT speedup related to <rdar://problem/5659272> REGRESSION: PLT .4%
slower due to r28884 (global variable symbol table optimization)

Geoff's theory is that the slowdown was due to copying hash tables when
putting things into the back/forward cache. If that's true, then this
should fix the problem.

(According to Geoff's measurements, in a PLT that exaggerates the
importance of symbol table saving during cached page creation, this
patch is a ~3X speedup in cached page creation, and a 9% speedup overall.)

• JavaScriptCore.exp: Updated.

• kjs/JSVariableObject.cpp: (KJS::JSVariableObject::saveLocalStorage): Updated for changes to SavedProperty, which has been revised to avoid initializing each SavedProperty twice when building the array. Store the property names too, so we don't have to store the symbol table separately. Do this by iterating the symbol table instead of the local storage vector. (KJS::JSVariableObject::restoreLocalStorage): Ditto. Restore the symbol table as well as the local storage vector.

• kjs/JSVariableObject.h: Removed save/restoreSymbolTable and do that work inside save/restoreLocalStorage instead. Made restoreLocalStorage a non-const member function that takes a const reference to a SavedProperties object.

• kjs/LocalStorage.h: Changed attributes to be unsigned instead of int to match other declarations of attributes elsewhere.

• kjs/property_map.cpp: (KJS::SavedProperties::SavedProperties): Updated for data member name change. (KJS::PropertyMap::save): Updated for data member name change and to use the new inline init function instead of setting the fields directly. This allows us to skip initializing the SavedProperty objects when first allocating the array, and just do it when we're actually setting up the individual elements. (KJS::PropertyMap::restore): Updated for SavedProperty changes.

• kjs/property_map.h: Changed SavedProperty from a struct to a class. Set it up so it does not get initialized at construction time to avoid initializing twice when creating an array of SavedProperty. Removed the m_ prefixes from the members of the SavedProperties struct. Generally we use m_ for class members and not struct.

WebCore:

Reviewed by Geoff Garen.

PLT speedup related to <rdar://problem/5659272> REGRESSION: PLT .4%
slower due to r28884 (global variable symbol table optimization)

• history/CachedPage.cpp: (WebCore::CachedPage::CachedPage): Removed saveSymbolTable call. (WebCore::CachedPage::restore): Removed restoreSymbolTable call. (WebCore::CachedPage::clear): Removed clear of m_windowSymbolTable.

• history/CachedPage.h: Removed m_windowSymbolTable, since save/restoreLocalStorage now takes care of the symbol table. Also removed many unnecessary includes.

File:

• trunk/JavaScriptCore/kjs/property_map.cpp (modified) (4 diffs)

trunk/JavaScriptCore/kjs/property_map.cpp

@@ -1 +1 @@
 /*
- *  Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
+ *  Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *
  *  This library is free software; you can redistribute it and/or
@@ -127 +127 @@
 
 SavedProperties::SavedProperties()
-    : m_count(0)
+    : count(0)
 {
 }
@@ -717 +717 @@
 }
 
-void PropertyMap::save(SavedProperties &p) const
+void PropertyMap::save(SavedProperties& s) const
 {
     unsigned count = 0;
@@ -733 +733 @@
     }
 
-    p.m_properties.clear();
-    p.m_count = count;
+    s.properties.clear();
+    s.count = count;
 
     if (count == 0)
         return;
     
-    p.m_properties.set(new SavedProperty [count]);
-    
-    SavedProperty* prop = p.m_properties.get();
-    
-    if (!m_usingTable) {
-#if USE_SINGLE_ENTRY
-        if (m_singleEntryKey && !(m_singleEntryAttributes & (ReadOnly | Function))) {
-            prop->key = Identifier(m_singleEntryKey);
-            prop->value = m_u.singleEntryValue;
-            prop->attributes = m_singleEntryAttributes;
-            ++prop;
-        }
-#endif
-    } else {
-        // Save in the right order so we don't lose the order.
-        // Another possibility would be to save the indices.
-
-        // Allocate a buffer to use to sort the keys.
-        Vector<Entry*, smallMapThreshold> sortedEntries(count);
-
-        // Get pointers to the entries in the buffer.
-        Entry** p = sortedEntries.data();
-        unsigned entryCount = m_u.table->keyCount + m_u.table->deletedSentinelCount;
-        for (unsigned i = 1; i <= entryCount; ++i) {
-            if (m_u.table->entries()[i].key && !(m_u.table->entries()[i].attributes & (ReadOnly | Function)))
-                *p++ = &m_u.table->entries()[i];
-        }
-        ASSERT(p == sortedEntries.data() + count);
-
-        // Sort the entries by index.
-        qsort(sortedEntries.data(), p - sortedEntries.data(), sizeof(Entry*), comparePropertyMapEntryIndices);
-
-        // Put the sorted entries into the saved properties list.
-        for (Entry** q = sortedEntries.data(); q != p; ++q, ++prop) {
-            Entry* e = *q;
-            prop->key = Identifier(e->key);
-            prop->value = e->value;
-            prop->attributes = e->attributes;
-        }
-    }
-}
-
-void PropertyMap::restore(const SavedProperties &p)
-{
-    for (unsigned i = 0; i != p.m_count; ++i)
-        put(p.m_properties[i].key, p.m_properties[i].value, p.m_properties[i].attributes);
+    s.properties.set(new SavedProperty[count]);
+    
+    SavedProperty* prop = s.properties.get();
+    
+#if USE_SINGLE_ENTRY
+    if (!m_usingTable) {
+        prop->init(m_singleEntryKey, m_u.singleEntryValue, m_singleEntryAttributes);
+        return;
+    }
+#endif
+
+    // Save in the right order so we don't lose the order.
+    // Another possibility would be to save the indices.
+
+    // Allocate a buffer to use to sort the keys.
+    Vector<Entry*, smallMapThreshold> sortedEntries(count);
+
+    // Get pointers to the entries in the buffer.
+    Entry** p = sortedEntries.data();
+    unsigned entryCount = m_u.table->keyCount + m_u.table->deletedSentinelCount;
+    for (unsigned i = 1; i <= entryCount; ++i) {
+        if (m_u.table->entries()[i].key && !(m_u.table->entries()[i].attributes & (ReadOnly | Function)))
+            *p++ = &m_u.table->entries()[i];
+    }
+    ASSERT(p == sortedEntries.data() + count);
+
+    // Sort the entries by index.
+    qsort(sortedEntries.data(), p - sortedEntries.data(), sizeof(Entry*), comparePropertyMapEntryIndices);
+
+    // Put the sorted entries into the saved properties list.
+    for (Entry** q = sortedEntries.data(); q != p; ++q, ++prop) {
+        Entry* e = *q;
+        prop->init(e->key, e->value, e->attributes);
+    }
+}
+
+void PropertyMap::restore(const SavedProperties& p)
+{
+    for (unsigned i = 0; i != p.count; ++i)
+        put(Identifier(p.properties[i].name()), p.properties[i].value(), p.properties[i].attributes());
 }