Changeset 51671 in webkit for trunk/JavaScriptCore/runtime/Operations.h

Timestamp:

Dec 3, 2009, 6:15:18 PM (15 years ago)

Author:

[email protected]

Message:

​https://bugs.webkit.org/show_bug.cgi?id=32136
Add a rope representation to JSString. Presently JSString always holds its data in UString form.
Instead, allow the result of a string concatenation to be represented in a tree form - with a
variable sized, reference-counted rope node retaining a set of UString::Reps (or other rope nopes).

Reviewed by Oliver "Brraaaaiiiinnnnnzzzzzzzz" Hunt.

Strings must still currently be resolved down to a flat UString representation before being used,
but by holding the string in a rope representation during construction we can avoid copying data
until we know the final size of the string.

~2% progression on SunSpider (~25% on date-format-xparb, ~20% on string-validate-input).

• JavaScriptCore.exp:

• Update exports.

• interpreter/Interpreter.cpp:

(JSC::Interpreter::privateExecute):

• Make use of new JSString::length() method to avoid prematurely resolving ropes.

• jit/JITOpcodes.cpp:

(JSC::JIT::privateCompileCTIMachineTrampolines):

• Switch the string length trampoline to read the length directly from JSString::m_length, rather than from the JSString's UString::Rep's 'len' property.

• jit/JITStubs.cpp:

(JSC::DEFINE_STUB_FUNCTION):

• Modify op_add such that addition of two strings, where either or both strings are already in rope representation, produces a rope as a result.

• runtime/JSString.cpp:

(JSC::JSString::Rope::~Rope):
(JSC::copyChars):
(JSC::JSString::resolveRope):
(JSC::JSString::getPrimitiveNumber):
(JSC::JSString::toBoolean):
(JSC::JSString::toNumber):
(JSC::JSString::toString):
(JSC::JSString::toThisString):
(JSC::JSString::getStringPropertyDescriptor):

• runtime/JSString.h:

(JSC::JSString::Rope::Fiber::Fiber):
(JSC::JSString::Rope::Fiber::destroy):
(JSC::JSString::Rope::Fiber::isRope):
(JSC::JSString::Rope::Fiber::rope):
(JSC::JSString::Rope::Fiber::string):
(JSC::JSString::Rope::create):
(JSC::JSString::Rope::initializeFiber):
(JSC::JSString::Rope::ropeLength):
(JSC::JSString::Rope::stringLength):
(JSC::JSString::Rope::fibers):
(JSC::JSString::Rope::Rope):
(JSC::JSString::Rope::operator new):
(JSC::JSString::JSString):
(JSC::JSString::value):
(JSC::JSString::length):
(JSC::JSString::isRope):
(JSC::JSString::rope):
(JSC::JSString::string):
(JSC::JSString::canGetIndex):
(JSC::jsSingleCharacterSubstring):
(JSC::JSString::getIndex):
(JSC::jsSubstring):
(JSC::JSString::getStringPropertySlot):

• Add rope form.

• runtime/Operations.h:

(JSC::jsAdd):
(JSC::concatenateStrings):

• Update string concatenation, and addition of ropes, to produce ropes.

• runtime/StringObject.cpp:

(JSC::StringObject::getOwnPropertyNames):

• Make use of new JSString::length() method to avoid prematurely resolving ropes.

File:

• trunk/JavaScriptCore/runtime/Operations.h (modified) (2 diffs)

trunk/JavaScriptCore/runtime/Operations.h

@@ -205 +205 @@
         bool leftIsString = v1.isString();
         if (leftIsString && v2.isString()) {
+            if (asString(v1)->isRope() || asString(v2)->isRope()) {
+                RefPtr<JSString::Rope> rope = JSString::Rope::create(2);
+                rope->initializeFiber(0, asString(v1));
+                rope->initializeFiber(1, asString(v2));
+                JSGlobalData* globalData = &callFrame->globalData();
+                return new (globalData) JSString(globalData, rope.release());
+            }
+
             RefPtr<UString::Rep> value = concatenate(asString(v1)->value().rep(), asString(v2)->value().rep());
             if (!value)
@@ -299 +307 @@
         ASSERT(count >= 3);
 
-        // Estimate the amount of space required to hold the entire string.  If all
-        // arguments are strings, we can easily calculate the exact amount of space
-        // required.  For any other arguments, for now let's assume they may require
-        // 11 UChars of storage.  This is enouch to hold any int, and likely is also
-        // reasonable for the other immediates.  We may want to come back and tune
-        // this value at some point.
-        unsigned bufferSize = 0;
+        RefPtr<JSString::Rope> rope = JSString::Rope::create(count);
+
         for (unsigned i = 0; i < count; ++i) {
             JSValue v = strings[i].jsValue();
             if (LIKELY(v.isString()))
-                bufferSize += asString(v)->value().size();
+                rope->initializeFiber(i, asString(v));
             else
-                bufferSize += 11;
-        }
-
-        // Allocate an output string to store the result.
-        // If the first argument is a String, and if it has the capacity (or can grow
-        // its capacity) to hold the entire result then use this as a base to concatenate
-        // onto.  Otherwise, allocate a new empty output buffer.
-        JSValue firstValue = strings[0].jsValue();
-        RefPtr<UString::Rep> resultRep;
-        if (firstValue.isString() && (resultRep = asString(firstValue)->value().rep())->reserveCapacity(bufferSize)) {
-            // We're going to concatenate onto the first string - remove it from the list of items to be appended.
-            ++strings;
-            --count;
-        } else
-            resultRep = UString::Rep::createEmptyBuffer(bufferSize);
-        UString result(resultRep);
-
-        // Loop over the operands, writing them into the output buffer.
-        for (unsigned i = 0; i < count; ++i) {
-            JSValue v = strings[i].jsValue();
-            if (LIKELY(v.isString()))
-                result.append(asString(v)->value());
-            else
-                result.append(v.toString(callFrame));
-        }
-
-        return jsString(callFrame, result);
-    }
-
+                rope->initializeFiber(i, v.toString(callFrame).rep());
+        }
+
+        JSGlobalData* globalData = &callFrame->globalData();
+        return new (globalData) JSString(globalData, rope.release());
+    }
 } // namespace JSC