Changeset 63268 in webkit for trunk/JavaScriptCore/runtime/JSArray.cpp

Timestamp:

Jul 13, 2010, 5:29:32 PM (15 years ago)

Author:

[email protected]

Message:

2010-07-13 Andreas Kling <​[email protected]>

Reviewed by Darin Adler.

Avoid slow-path for put() in Array.splice()
​https://bugs.webkit.org/show_bug.cgi?id=41920

Defer creation of the returned array until its final size is known
to avoid growing it while adding elements.

• runtime/JSArray.cpp: (JSC::JSArray::JSArray): Add two modes of creation, CreateInitialized (old) and CreateCompact (which should only be used when constructing arrays whose size and contents are known at the time of creation.) (JSC::JSArray::setLength): Skip first consistency check if in CreateCompact initialization mode. (Only applies to non-empty arrays.) (JSC::JSArray::checkConsistency): Build fix (JSValue::type() is gone)
• runtime/JSArray.h: (JSC::JSArray::uncheckedSetIndex): Added for fast initialization of compact arrays. Does no bounds or other sanity checking.
• runtime/ArrayPrototype.cpp: (JSC::arrayProtoFuncSplice): Optimized creation of the returned JSArray.
• runtime/ArrayConstructor.cpp: (JSC::constructArrayWithSizeQuirk): Pass CreateInitialized to ctor.
• runtime/JSGlobalObject.h: (JSC::constructEmptyArray): Pass CreateInitialized to ctor.
• runtime/RegExpConstructor.cpp: (JSC::RegExpMatchesArray::RegExpMatchesArray): Pass CreateInitialized to ctor.

File:

• trunk/JavaScriptCore/runtime/JSArray.cpp (modified) (6 diffs)

trunk/JavaScriptCore/runtime/JSArray.cpp

@@ -33 +33 @@
 #include <wtf/OwnPtr.h>
 #include <Operations.h>
-
-#define CHECK_ARRAY_CONSISTENCY 0
 
 using namespace std;
@@ -142 +140 @@
 }
 
-JSArray::JSArray(NonNullPassRefPtr<Structure> structure, unsigned initialLength)
+JSArray::JSArray(NonNullPassRefPtr<Structure> structure, unsigned initialLength, ArrayCreationMode creationMode)
     : JSObject(structure)
 {
-    unsigned initialCapacity = min(initialLength, MIN_SPARSE_ARRAY_INDEX);
+    unsigned initialCapacity;
+    if (creationMode == CreateCompact)
+        initialCapacity = initialLength;
+    else
+        initialCapacity = min(initialLength, MIN_SPARSE_ARRAY_INDEX);
 
     m_storage = static_cast<ArrayStorage*>(fastMalloc(storageSize(initialCapacity)));
-    m_storage->m_length = initialLength;
     m_vectorLength = initialCapacity;
-    m_storage->m_numValuesInVector = 0;
     m_storage->m_sparseValueMap = 0;
     m_storage->subclassData = 0;
     m_storage->reportedMapCapacity = 0;
 
-    JSValue* vector = m_storage->m_vector;
-    for (size_t i = 0; i < initialCapacity; ++i)
-        vector[i] = JSValue();
+    if (creationMode == CreateCompact) {
+#if CHECK_ARRAY_CONSISTENCY
+        m_storage->m_inCompactInitialization = !!initialCapacity;
+#endif
+        m_storage->m_length = 0;
+        m_storage->m_numValuesInVector = initialCapacity;
+    } else {
+#if CHECK_ARRAY_CONSISTENCY
+        m_storage->m_inCompactInitialization = false;
+#endif
+        m_storage->m_length = initialLength;
+        m_storage->m_numValuesInVector = 0;
+        JSValue* vector = m_storage->m_vector;
+        for (size_t i = 0; i < initialCapacity; ++i)
+            vector[i] = JSValue();
+    }
 
     checkConsistency();
@@ -176 +189 @@
     m_storage->subclassData = 0;
     m_storage->reportedMapCapacity = 0;
+#if CHECK_ARRAY_CONSISTENCY
+    m_storage->m_inCompactInitialization = false;
+#endif
 
     size_t i = 0;
@@ -525 +541 @@
 void JSArray::setLength(unsigned newLength)
 {
-    checkConsistency();
+#if CHECK_ARRAY_CONSISTENCY
+    if (!m_storage->m_inCompactInitialization)
+        checkConsistency();
+    else
+        m_storage->m_inCompactInitialization = false;
+#endif
 
     ArrayStorage* storage = m_storage;
@@ -1046 +1067 @@
             ASSERT(i < m_storage->m_length);
             if (type != DestructorConsistencyCheck)
-                value->type(); // Likely to crash if the object was deallocated.
+                value.isUndefined(); // Likely to crash if the object was deallocated.
             ++numValuesInVector;
         } else {
@@ -1065 +1086 @@
             ASSERT(it->second);
             if (type != DestructorConsistencyCheck)
-                it->second->type(); // Likely to crash if the object was deallocated.
+                it->second.isUndefined(); // Likely to crash if the object was deallocated.
         }
     }