Changeset 84515 in webkit for trunk/Source/JavaScriptCore/runtime/JSString.cpp

Timestamp:

Apr 21, 2011, 10:23:16 AM (14 years ago)

Author:

[email protected]

Message:

2011-04-20 Michael Saboff <​[email protected]>

Reviewed by Geoff Garen.

JSString::resolveRope inefficient for common 2 fiber case
​https://bugs.webkit.org/show_bug.cgi?id=58994

Split JSString::resolveRope into three routines.
resolveRope allocates the new buffer and handles the 1 or 2
fiber case with single level fibers.
resolveRopeSlowCase handles the general case.
outOfMemory handles the rare out of memory exception case.

• runtime/JSString.cpp: (JSC::JSString::resolveRope): (JSC::JSString::resolveRopeSlowCase): (JSC::JSString::outOfMemory):
• runtime/JSString.h:

File:

• trunk/Source/JavaScriptCore/runtime/JSString.cpp (modified) (4 diffs)

trunk/Source/JavaScriptCore/runtime/JSString.cpp

@@ -35 +35 @@
 static const unsigned substringFromRopeCutoff = 4;
 
+void JSString::resolveRope(ExecState* exec) const
+{
+    ASSERT(isRope());
+
+    UChar* buffer;
+    if (PassRefPtr<StringImpl> newImpl = StringImpl::tryCreateUninitialized(m_length, buffer))
+        m_value = newImpl;
+    else {
+        outOfMemory(exec);
+        return;
+    }
+
+    RopeImpl::Fiber currentFiber = m_other.m_fibers[0];
+
+    if ((m_fiberCount > 2) || (RopeImpl::isRope(currentFiber)) 
+        || ((m_fiberCount == 2) && (RopeImpl::isRope(m_other.m_fibers[1])))) {
+        resolveRopeSlowCase(exec, buffer);
+        return;
+    }
+
+    UChar* position = buffer;
+    StringImpl* string = static_cast<StringImpl*>(currentFiber);
+    unsigned length = string->length();
+    StringImpl::copyChars(position, string->characters(), length);
+
+    if (m_fiberCount > 1) {
+        position += length;
+        currentFiber = m_other.m_fibers[1];
+        string = static_cast<StringImpl*>(currentFiber);
+        length = string->length();
+        StringImpl::copyChars(position, string->characters(), length);
+        position += length;
+    }
+
+    ASSERT((buffer + m_length) == position);
+    for (unsigned i = 0; i < m_fiberCount; ++i) {
+        RopeImpl::deref(m_other.m_fibers[i]);
+        m_other.m_fibers[i] = 0;
+    }
+    m_fiberCount = 0;
+
+    ASSERT(!isRope());
+}
+
 // Overview: this methods converts a JSString from holding a string in rope form
 // down to a simple UString representation.  It does so by building up the string
@@ -44 +88 @@
 // Vector before performing any concatenation, but by working backwards we likely
 // only fill the queue with the number of substrings at any given level in a
-// rope-of-ropes.)
-void JSString::resolveRope(ExecState* exec) const
-{
-    ASSERT(isRope());
-
-    // Allocate the buffer to hold the final string, position initially points to the end.
-    UChar* buffer;
-    if (PassRefPtr<StringImpl> newImpl = StringImpl::tryCreateUninitialized(m_length, buffer))
-        m_value = newImpl;
-    else {
-        for (unsigned i = 0; i < m_fiberCount; ++i) {
-            RopeImpl::deref(m_other.m_fibers[i]);
-            m_other.m_fibers[i] = 0;
-        }
-        m_fiberCount = 0;
-        ASSERT(!isRope());
-        ASSERT(m_value == UString());
-        if (exec)
-            throwOutOfMemoryError(exec);
-        return;
-    }
+// rope-of-ropes.)    
+void JSString::resolveRopeSlowCase(ExecState* exec, UChar* buffer) const
+{
+    UNUSED_PARAM(exec);
+
     UChar* position = buffer + m_length;
 
@@ -97 +125 @@
                 }
                 m_fiberCount = 0;
-
+                
                 ASSERT(!isRope());
                 return;
@@ -108 +136 @@
     }
 }
-    
+
+void JSString::outOfMemory(ExecState* exec) const
+{
+    for (unsigned i = 0; i < m_fiberCount; ++i) {
+        RopeImpl::deref(m_other.m_fibers[i]);
+        m_other.m_fibers[i] = 0;
+    }
+    m_fiberCount = 0;
+    ASSERT(!isRope());
+    ASSERT(m_value == UString());
+    if (exec)
+        throwOutOfMemoryError(exec);
+}
+
 // This function construsts a substring out of a rope without flattening by reusing the existing fibers.
 // This can reduce memory usage substantially. Since traversing ropes is slow the function will revert