Changeset 43383 in webkit for trunk/JavaScriptCore/runtime

Timestamp:

May 7, 2009, 6:58:47 PM (16 years ago)

Author:

[email protected]

Message:

2009-05-07 Gavin Barraclough <​[email protected]>

Reviewed by Maciej Stachowiak.

Previously, when appending to an existing string and growing the underlying buffer,
we would actually allocate 110% of the required size in order to give us some space
to expand into. Now we treat strings differently based on their size:

Small Strings (up to 4 pages):
Expand the allocation size to 112.5% of the amount requested. This is largely sicking
to our previous policy, however 112.5% is cheaper to calculate.

Medium Strings (up to 128 pages):
For pages covering multiple pages over-allocation is less of a concern - any unused
space will not be paged in if it is not used, so this is purely a VM overhead. For
these strings allocate 2x the requested size.

Large Strings (to infinity and beyond!):
Revert to our 112.5% policy - probably best to limit the amount of unused VM we allow
any individual string be responsible for.

Additionally, round small allocations up to a multiple of 16 bytes, and medium and
large allocations up to a multiple of page size.

~1.5% progression on Sunspider, due to 5% improvement on tagcloud & 15% on validate.

• runtime/UString.cpp: (JSC::expandedSize):

File:

• trunk/JavaScriptCore/runtime/UString.cpp (modified) (1 diff)

trunk/JavaScriptCore/runtime/UString.cpp

@@ -369 +369 @@
 #endif
 
-// put these early so they can be inlined
-static inline size_t expandedSize(size_t size, size_t otherSize)
-{
-    // Do the size calculation in two parts, returning overflowIndicator if
-    // we overflow the maximum value that we can handle.
-
-    if (size > maxUChars())
+// Put these early so they can be inlined.
+static inline size_t expandedSize(size_t capacitySize, size_t precapacitySize)
+{
+    // Combine capacitySize & precapacitySize to produce a single size to allocate,
+    // check that doing so does not result in overflow.
+    size_t size = capacitySize + precapacitySize;
+    if (size < capacitySize)
         return overflowIndicator();
 
-    size_t expandedSize = ((size + 10) / 10 * 11) + 1;
-
-    // If 'size' was originally just less than maxUChars() then we may have just overflowed.
-    // The next check won't catch this, since the subtraction will underflow.  Alternatively,
-    // rather than failing we could just back off from the expansion here?
-    if (expandedSize > maxUChars())
-        return overflowIndicator();
-
-    if (maxUChars() - expandedSize < otherSize)
-        return overflowIndicator();
-
-    return expandedSize + otherSize;
+    // Small Strings (up to 4 pages):
+    // Expand the allocation size to 112.5% of the amount requested.  This is largely sicking
+    // to our previous policy, however 112.5% is cheaper to calculate.
+    if (size < 0x4000) {
+        size_t expandedSize = ((size + (size >> 3)) | 15) + 1;
+        // Given the limited range within which we calculate the expansion in this
+        // fashion the above calculation should never overflow.
+        ASSERT(expandedSize >= size);
+        ASSERT(expandedSize < maxUChars());
+        return expandedSize;
+    }
+
+    // Medium Strings (up to 128 pages):
+    // For pages covering multiple pages over-allocation is less of a concern - any unused
+    // space will not be paged in if it is not used, so this is purely a VM overhead.  For
+    // these strings allocate 2x the requested size.
+    if (size < 0x80000) {
+        size_t expandedSize = ((size + size) | 0xfff) + 1;
+        // Given the limited range within which we calculate the expansion in this
+        // fashion the above calculation should never overflow.
+        ASSERT(expandedSize >= size);
+        ASSERT(expandedSize < maxUChars());
+        return expandedSize;
+    }
+
+    // Large Strings (to infinity and beyond!):
+    // Revert to our 112.5% policy - probably best to limit the amount of unused VM we allow
+    // any individual string be responsible for.
+    size_t expandedSize = ((size + (size >> 3)) | 0xfff) + 1;
+
+    // Check for overflow - any result that is at least as large as requested (but
+    // still below the limit) is okay.
+    if ((expandedSize >= size) && (expandedSize < maxUChars()))
+        return expandedSize;
+    return overflowIndicator();
 }