Changeset 118019 in webkit for trunk/Source/JavaScriptCore/heap/Heap.cpp

Timestamp:

May 22, 2012, 12:17:57 PM (13 years ago)

Author:

[email protected]

Message:

GC allocation trigger should be tuned to system RAM
​https://bugs.webkit.org/show_bug.cgi?id=87039

Reviewed by Darin Adler.

../JavaScriptCore:

This helps avoid OOM crashes on small platforms, and helps avoid "too much GC"
performance issues on big platforms.

• heap/Heap.cpp:

(JSC::Heap::Heap):
(JSC::Heap::collect):

• heap/Heap.h:

(Heap): GC balances between a fixed minimum and a proportional multiplier,
which are limited based on system RAM.

• runtime/JSGlobalData.cpp:

(JSC::JSGlobalData::JSGlobalData):
(JSC::JSGlobalData::createContextGroup):
(JSC::JSGlobalData::create):
(JSC::JSGlobalData::createLeaked):

• runtime/JSGlobalData.h:

(JSGlobalData): Renamed HeapSize to HeapType because the exact size is
influenced by the heap type, but not determined by it.

../WTF:

Added a helper function for measuring system RAM.

• GNUmakefile.list.am:
• WTF.gypi:
• WTF.pro:
• WTF.vcproj/WTF.vcproj:
• WTF.xcodeproj/project.pbxproj:
• wtf/AmountOfRAM.cpp: Added.

(WTF):
(WTF::computeAmountOfRAM):
(WTF::amountOfRAM):

• wtf/AmountOfRAM.h: Added.

(WTF):

• wtf/CMakeLists.txt:
• wtf/StdLibExtras.h:

(WTF):

File:

• trunk/Source/JavaScriptCore/heap/Heap.cpp (modified) (5 diffs)

trunk/Source/JavaScriptCore/heap/Heap.cpp

@@ -36 +36 @@
 #include "WeakSetInlines.h"
 #include <algorithm>
+#include <wtf/RAMSize.h>
 #include <wtf/CurrentTime.h>
-
 
 using namespace std;
@@ -46 +46 @@
 namespace { 
 
-#if CPU(X86) || CPU(X86_64)
-static const size_t largeHeapSize = 16 * 1024 * 1024;
-#elif PLATFORM(IOS)
-static const size_t largeHeapSize = 8 * 1024 * 1024;
-#else
-static const size_t largeHeapSize = 512 * 1024;
-#endif
-static const size_t smallHeapSize = 512 * 1024;
+static const size_t largeHeapSize = 32 * MB; // About 1.5X the average webpage.
+static const size_t smallHeapSize = 1 * MB; // Matches the FastMalloc per-thread cache.
 
 #if ENABLE(GC_LOGGING)
@@ -149 +143 @@
 #endif
 
-static size_t heapSizeForHint(HeapSize heapSize)
-{
-    if (heapSize == LargeHeap)
-        return largeHeapSize;
-    ASSERT(heapSize == SmallHeap);
+static inline size_t minHeapSize(HeapType heapType, size_t ramSize)
+{
+    if (heapType == LargeHeap)
+        return min(largeHeapSize, ramSize / 4);
     return smallHeapSize;
+}
+
+static inline size_t proportionalHeapSize(size_t heapSize, size_t ramSize)
+{
+    // Try to stay under 1/2 RAM size to leave room for the DOM, rendering, networking, etc.
+    if (heapSize < ramSize / 4)
+        return 2 * heapSize;
+    if (heapSize < ramSize / 2)
+        return 1.5 * heapSize;
+    return 1.25 * heapSize;
 }
 
@@ -231 +234 @@
 } // anonymous namespace
 
-Heap::Heap(JSGlobalData* globalData, HeapSize heapSize)
-    : m_heapSize(heapSize)
-    , m_minBytesPerCycle(heapSizeForHint(heapSize))
+Heap::Heap(JSGlobalData* globalData, HeapType heapType)
+    : m_heapType(heapType)
+    , m_ramSize(ramSize())
+    , m_minBytesPerCycle(minHeapSize(m_heapType, m_ramSize))
     , m_sizeAfterLastCollect(0)
     , m_bytesAllocatedLimit(m_minBytesPerCycle)
@@ -723 +727 @@
     }
 
-    // To avoid pathological GC churn in large heaps, we set the new allocation 
-    // limit to be the current size of the heap. This heuristic 
-    // is a bit arbitrary. Using the current size of the heap after this 
-    // collection gives us a 2X multiplier, which is a 1:1 (heap size :
-    // new bytes allocated) proportion, and seems to work well in benchmarks.
-    size_t newSize = size();
+    size_t currentHeapSize = size();
     if (fullGC) {
-        m_sizeAfterLastCollect = newSize;
-        m_bytesAllocatedLimit = max(newSize, m_minBytesPerCycle);
+        m_sizeAfterLastCollect = currentHeapSize;
+
+        // To avoid pathological GC churn in very small and very large heaps, we set
+        // the new allocation limit based on the current size of the heap, with a
+        // fixed minimum.
+        size_t maxHeapSize = max(minHeapSize(m_heapType, m_ramSize), proportionalHeapSize(currentHeapSize, m_ramSize));
+        m_bytesAllocatedLimit = maxHeapSize - currentHeapSize;
     }
     m_bytesAllocated = 0;