Changeset 195575 in webkit

Timestamp:

Jan 25, 2016 6:57:51 PM (8 years ago)

Author:

akling@apple.com

Message:

MarkedSpace should have more precise allocators.
<​https://webkit.org/b/153448>
<rdar://problem/23897477>

Reviewed by Geoffrey Garen.

The four classes responsible for the bulk of MarkedBlock allocations today are:

• FunctionCodeBlock (640 bytes)
• UnlinkedFunctionCodeBlock (304 bytes)
• FunctionExecutable (168 bytes)
• UnlinkedFunctionExecutable (144 bytes)

Due to the size class distribution in MarkedSpace, we've been wasting quite a lot
of heap space on these objects. Our "precise" allocators allowed allocation sizes
in 16-byte increments up to 128 bytes, but after that point, we'd only allocate
in 256-byte size increments.

Thus each instance of those classes would waste space as follows:

• FunctionCodeBlock (768-byte cell, 128 bytes wasted)
• UnlinkedFunctionCodeBlock (512-byte cell, 208 bytes wasted)
• FunctionExecutable(256-byte cell, 88 bytes wasted)
• UnlinkedFunctionExecutable(256-byte cell, 112 bytes wasted)

This patch raises the limit for precise allocations from 128 to 768, allowing us
to allocate these objects with far better space efficiency.

The cost of this is 7kB worth of MarkedAllocators and 70 (~2x) more allocators to
iterate whenever we iterate all the allocators.

• heap/MarkedSpace.h:
• heap/MarkedSpace.cpp:

(JSC::MarkedSpace::MarkedSpace):
(JSC::MarkedSpace::resetAllocators):
(JSC::MarkedSpace::forEachAllocator):
(JSC::MarkedSpace::isPagedOut):

Location:

trunk/Source/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• heap/MarkedSpace.cpp (modified) (4 diffs)
• heap/MarkedSpace.h (modified) (1 diff)

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2016-01-25  Andreas Kling  <akling@apple.com>
+
+        MarkedSpace should have more precise allocators.
+        <https://webkit.org/b/153448>
+        <rdar://problem/23897477>
+
+        Reviewed by Geoffrey Garen.
+
+        The four classes responsible for the bulk of MarkedBlock allocations today are:
+
+            - FunctionCodeBlock (640 bytes)
+            - UnlinkedFunctionCodeBlock (304 bytes)
+            - FunctionExecutable (168 bytes)
+            - UnlinkedFunctionExecutable (144 bytes)
+
+        Due to the size class distribution in MarkedSpace, we've been wasting quite a lot
+        of heap space on these objects. Our "precise" allocators allowed allocation sizes
+        in 16-byte increments up to 128 bytes, but after that point, we'd only allocate
+        in 256-byte size increments.
+
+        Thus each instance of those classes would waste space as follows:
+
+            - FunctionCodeBlock (768-byte cell, 128 bytes wasted)
+            - UnlinkedFunctionCodeBlock (512-byte cell, 208 bytes wasted)
+            - FunctionExecutable(256-byte cell, 88 bytes wasted)
+            - UnlinkedFunctionExecutable(256-byte cell, 112 bytes wasted)
+
+        This patch raises the limit for precise allocations from 128 to 768, allowing us
+        to allocate these objects with far better space efficiency.
+
+        The cost of this is 7kB worth of MarkedAllocators and 70 (~2x) more allocators to
+        iterate whenever we iterate all the allocators.
+
+        * heap/MarkedSpace.h:
+        * heap/MarkedSpace.cpp:
+        (JSC::MarkedSpace::MarkedSpace):
+        (JSC::MarkedSpace::resetAllocators):
+        (JSC::MarkedSpace::forEachAllocator):
+        (JSC::MarkedSpace::isPagedOut):
+
 2016-01-25  Filip Pizlo  <fpizlo@apple.com>
 

trunk/Source/JavaScriptCore/heap/MarkedSpace.cpp

@@ -63 +63 @@
     }
 
-    for (size_t cellSize = impreciseStep; cellSize <= impreciseCutoff; cellSize += impreciseStep) {
+    for (size_t cellSize = impreciseStart; cellSize <= impreciseCutoff; cellSize += impreciseStep) {
         allocatorFor(cellSize).init(heap, this, cellSize, false);
         destructorAllocatorFor(cellSize).init(heap, this, cellSize, true);
@@ -110 +110 @@
     }
 
-    for (size_t cellSize = impreciseStep; cellSize <= impreciseCutoff; cellSize += impreciseStep) {
+    for (size_t cellSize = impreciseStart; cellSize <= impreciseCutoff; cellSize += impreciseStep) {
         allocatorFor(cellSize).reset();
         destructorAllocatorFor(cellSize).reset();
@@ -155 +155 @@
     }
 
-    for (size_t cellSize = impreciseStep; cellSize <= impreciseCutoff; cellSize += impreciseStep) {
+    for (size_t cellSize = impreciseStart; cellSize <= impreciseCutoff; cellSize += impreciseStep) {
         functor(allocatorFor(cellSize));
         functor(destructorAllocatorFor(cellSize));
@@ -192 +192 @@
     }
 
-    for (size_t cellSize = impreciseStep; cellSize <= impreciseCutoff; cellSize += impreciseStep) {
+    for (size_t cellSize = impreciseStart; cellSize <= impreciseCutoff; cellSize += impreciseStep) {
         if (allocatorFor(cellSize).isPagedOut(deadline) 
             || destructorAllocatorFor(cellSize).isPagedOut(deadline))

trunk/Source/JavaScriptCore/heap/MarkedSpace.h

@@ -68 +68 @@
     WTF_MAKE_NONCOPYABLE(MarkedSpace);
 public:
-    // [ 16 ... 128 ]
+    // [ 16 ... 768 ]
     static const size_t preciseStep = MarkedBlock::atomSize;
-    static const size_t preciseCutoff = 128;
+    static const size_t preciseCutoff = 768;
     static const size_t preciseCount = preciseCutoff / preciseStep;
 
-    // [ 256 ... blockSize/2 ]
-    static const size_t impreciseStep = 2 * preciseCutoff;
+    // [ 1024 ... blockSize/2 ]
+    static const size_t impreciseStart = 1024;
+    static const size_t impreciseStep = 256;
     static const size_t impreciseCutoff = MarkedBlock::blockSize / 2;
     static const size_t impreciseCount = impreciseCutoff / impreciseStep;