Changeset 141716 in webkit

Timestamp:

Feb 3, 2013 5:37:41 AM (11 years ago)

Author:

akling@apple.com

Message:

Vector should consult allocator about ideal size when choosing capacity.
<​http://webkit.org/b/108410>
<rdar://problem/13124002>

Reviewed by Benjamin Poulain.

Source/JavaScriptCore:

Remove assertion about Vector capacity that won't hold anymore since capacity()
may not be what you passed to reserveCapacity().
Also export WTF::fastMallocGoodSize() for Windows builds.

• JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCoreExports.def:
• bytecode/CodeBlock.cpp:

(JSC::CodeBlock::CodeBlock):

Source/WTF:

Added WTF::fastMallocGoodSize(), a workalike/wrapper for OS X's malloc_good_size().
It returns the actual size of the block that will get allocated for a given byte size.

Vector's internal buffer now checks with the allocator if the resulting allocation
could actually house more objects and updates its capacity to make use of the space.

• wtf/Deque.h:

(WTF::::expandCapacity):

• wtf/FastMalloc.cpp:

(WTF::fastMallocGoodSize):

• wtf/FastMalloc.h:
• wtf/Vector.h:

(WTF::VectorBufferBase::allocateBuffer):
(WTF::VectorBufferBase::tryAllocateBuffer):
(WTF::VectorBufferBase::reallocateBuffer):

Location:

trunk/Source

Files:

• JavaScriptCore/ChangeLog (modified) (1 diff)
• JavaScriptCore/JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCoreExports.def (modified) (1 diff)
• JavaScriptCore/bytecode/CodeBlock.cpp (modified) (1 diff)
• WTF/ChangeLog (modified) (1 diff)
• WTF/wtf/Deque.h (modified) (1 diff)
• WTF/wtf/FastMalloc.cpp (modified) (2 diffs)
• WTF/wtf/FastMalloc.h (modified) (2 diffs)
• WTF/wtf/Vector.h (modified) (3 diffs)

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2013-02-02  Andreas Kling  <akling@apple.com>
+
+        Vector should consult allocator about ideal size when choosing capacity.
+        <http://webkit.org/b/108410>
+        <rdar://problem/13124002>
+
+        Reviewed by Benjamin Poulain.
+
+        Remove assertion about Vector capacity that won't hold anymore since capacity()
+        may not be what you passed to reserveCapacity().
+        Also export WTF::fastMallocGoodSize() for Windows builds.
+
+        * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCoreExports.def:
+        * bytecode/CodeBlock.cpp:
+        (JSC::CodeBlock::CodeBlock):
+
 2013-02-02  Patrick Gansterer  <paroga@webkit.org>
 

trunk/Source/JavaScriptCore/JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCoreExports.def

@@ -207 +207 @@
     ?fastFree@WTF@@YAXPAX@Z
     ?fastMalloc@WTF@@YAPAXI@Z
+    ?fastMallocGoodSize@WTF@@YAII@Z
     ?fastMallocMatchFailed@Internal@WTF@@YAXPAX@Z
     ?fastMallocSize@WTF@@YAIPBX@Z

trunk/Source/JavaScriptCore/bytecode/CodeBlock.cpp

@@ -1821 +1821 @@
         m_resolveOperations.grow(size);
     size_t putToBaseCount = unlinkedCodeBlock->numberOfPutToBaseOperations();
-    m_putToBaseOperations.reserveCapacity(putToBaseCount);
+    m_putToBaseOperations.reserveInitialCapacity(putToBaseCount);
     for (size_t i = 0; i < putToBaseCount; ++i)
-        m_putToBaseOperations.append(PutToBaseOperation(isStrictMode()));
-
-    ASSERT(m_putToBaseOperations.capacity() == putToBaseCount);
+        m_putToBaseOperations.uncheckedAppend(PutToBaseOperation(isStrictMode()));
 
     // Copy and translate the UnlinkedInstructions

trunk/Source/WTF/ChangeLog

@@ +1 @@
+2013-02-02  Andreas Kling  <akling@apple.com>
+
+        Vector should consult allocator about ideal size when choosing capacity.
+        <http://webkit.org/b/108410>
+        <rdar://problem/13124002>
+
+        Reviewed by Benjamin Poulain.
+
+        Added WTF::fastMallocGoodSize(), a workalike/wrapper for OS X's malloc_good_size().
+        It returns the actual size of the block that will get allocated for a given byte size.
+
+        Vector's internal buffer now checks with the allocator if the resulting allocation
+        could actually house more objects and updates its capacity to make use of the space.
+
+        * wtf/Deque.h:
+        (WTF::::expandCapacity):
+        * wtf/FastMalloc.cpp:
+        (WTF::fastMallocGoodSize):
+        * wtf/FastMalloc.h:
+        * wtf/Vector.h:
+        (WTF::VectorBufferBase::allocateBuffer):
+        (WTF::VectorBufferBase::tryAllocateBuffer):
+        (WTF::VectorBufferBase::reallocateBuffer):
+
 2013-02-02  Mark Rowe  <mrowe@apple.com>
 

trunk/Source/WTF/wtf/Deque.h

@@ -384 +384 @@
         checkValidity();
         size_t oldCapacity = m_buffer.capacity();
-        size_t newCapacity = std::max(static_cast<size_t>(16), oldCapacity + oldCapacity / 4 + 1);
         T* oldBuffer = m_buffer.buffer();
-        m_buffer.allocateBuffer(newCapacity);
+        m_buffer.allocateBuffer(std::max(static_cast<size_t>(16), oldCapacity + oldCapacity / 4 + 1));
         if (m_start <= m_end)
             TypeOperations::move(oldBuffer + m_start, oldBuffer + m_end, m_buffer.buffer() + m_start);
         else {
             TypeOperations::move(oldBuffer, oldBuffer + m_end, m_buffer.buffer());
-            size_t newStart = newCapacity - (oldCapacity - m_start);
+            size_t newStart = m_buffer.capacity() - (oldCapacity - m_start);
             TypeOperations::move(oldBuffer + m_start, oldBuffer + oldCapacity, m_buffer.buffer() + newStart);
             m_start = newStart;

trunk/Source/WTF/wtf/FastMalloc.cpp

@@ -238 +238 @@
 namespace WTF {
 
+size_t fastMallocGoodSize(size_t bytes)
+{
+#if OS(DARWIN)
+    return malloc_good_size(bytes);
+#else
+    return bytes;
+#endif
+}
+
 TryMallocReturnValue tryFastMalloc(size_t n) 
 {
@@ -2557 +2566 @@
 
 #define pageheap getPageHeap()
+
+size_t fastMallocGoodSize(size_t bytes)
+{
+    if (!phinited)
+        TCMalloc_ThreadCache::InitModule();
+    return AllocationSize(bytes);
+}
 
 #if USE_BACKGROUND_THREAD_TO_SCAVENGE_MEMORY

trunk/Source/WTF/wtf/FastMalloc.h

@@ -36 +36 @@
     WTF_EXPORT_PRIVATE char* fastStrDup(const char*);
     WTF_EXPORT_PRIVATE size_t fastMallocSize(const void*);
+    WTF_EXPORT_PRIVATE size_t fastMallocGoodSize(size_t);
 
     struct TryMallocReturnValue {
@@ -224 +225 @@
 using WTF::fastFree;
 using WTF::fastMalloc;
+using WTF::fastMallocGoodSize;
 using WTF::fastMallocSize;
 using WTF::fastRealloc;

trunk/Source/WTF/wtf/Vector.h

@@ -253 +253 @@
         {
             ASSERT(newCapacity);
-            m_capacity = newCapacity;
             if (newCapacity > std::numeric_limits<size_t>::max() / sizeof(T))
                 CRASH();
-            m_buffer = static_cast<T*>(fastMalloc(newCapacity * sizeof(T)));
+            size_t sizeToAllocate = fastMallocGoodSize(newCapacity * sizeof(T));
+            m_capacity = sizeToAllocate / sizeof(T);
+            m_buffer = static_cast<T*>(fastMalloc(sizeToAllocate));
         }
 
@@ -265 +266 @@
                 return false;
 
+            size_t sizeToAllocate = fastMallocGoodSize(newCapacity * sizeof(T));
             T* newBuffer;
-            if (tryFastMalloc(newCapacity * sizeof(T)).getValue(newBuffer)) {
-                m_capacity = newCapacity;
+            if (tryFastMalloc(sizeToAllocate).getValue(newBuffer)) {
+                m_capacity = sizeToAllocate / sizeof(T);
                 m_buffer = newBuffer;
                 return true;
@@ -282 +284 @@
         {
             ASSERT(shouldReallocateBuffer(newCapacity));
-            m_capacity = newCapacity;
             if (newCapacity > std::numeric_limits<size_t>::max() / sizeof(T))
                 CRASH();
-            m_buffer = static_cast<T*>(fastRealloc(m_buffer, newCapacity * sizeof(T)));
+            size_t sizeToAllocate = fastMallocGoodSize(newCapacity * sizeof(T));
+            m_capacity = sizeToAllocate / sizeof(T);
+            m_buffer = static_cast<T*>(fastRealloc(m_buffer, sizeToAllocate));
         }