Changeset 147150 in webkit

Timestamp:

Mar 28, 2013 1:21:08 PM (11 years ago)

Author:

mhahnenberg@apple.com

Message:

Safari hangs during test262 run in CodeCache::pruneSlowCase
​https://bugs.webkit.org/show_bug.cgi?id=113469

Reviewed by Geoffrey Garen.

We can end up hanging for quite some time if we add a lot of small keys to the CodeCache.
By the time we get around to pruning the cache, we have a potentially tens or hundreds of
thousands of small entries, which can cause a noticeable hang when pruning them.

To fix this issue we added a hard cap to the number of entries in the cache because we
could potentially have to remove every element in the map.

• runtime/CodeCache.cpp:

(JSC::CodeCacheMap::pruneSlowCase): We need to prune until we're both under the hard cap and the
capacity in bytes.

• runtime/CodeCache.h:

(CodeCacheMap):
(JSC::CodeCacheMap::numberOfEntries): Convenience accessor function to the number of entries in
the map that does the cast to size_t of m_map.size() for us.
(JSC::CodeCacheMap::canPruneQuickly): Checks that the total number is under the hard cap. We put this
check inside a function to more accurately describe why we're doing the check and to abstract out
the actual calculation in case we want to coalesce calls to pruneSlowCase in the future.
(JSC::CodeCacheMap::prune): Check the number of entries against our hard cap. If it's greater than
the cap then we need to drop down to pruneSlowCase.

Location:

trunk/Source/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• runtime/CodeCache.cpp (modified) (1 diff)
• runtime/CodeCache.h (modified) (2 diffs)

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2013-03-28  Mark Hahnenberg  <mhahnenberg@apple.com>
+
+        Safari hangs during test262 run in CodeCache::pruneSlowCase
+        https://bugs.webkit.org/show_bug.cgi?id=113469
+
+        Reviewed by Geoffrey Garen.
+
+        We can end up hanging for quite some time if we add a lot of small keys to the CodeCache.
+        By the time we get around to pruning the cache, we have a potentially tens or hundreds of 
+        thousands of small entries, which can cause a noticeable hang when pruning them.
+
+        To fix this issue we added a hard cap to the number of entries in the cache because we 
+        could potentially have to remove every element in the map.
+
+        * runtime/CodeCache.cpp:
+        (JSC::CodeCacheMap::pruneSlowCase): We need to prune until we're both under the hard cap and the
+        capacity in bytes.
+        * runtime/CodeCache.h:
+        (CodeCacheMap):
+        (JSC::CodeCacheMap::numberOfEntries): Convenience accessor function to the number of entries in 
+        the map that does the cast to size_t of m_map.size() for us. 
+        (JSC::CodeCacheMap::canPruneQuickly): Checks that the total number is under the hard cap. We put this 
+        check inside a function to more accurately describe why we're doing the check and to abstract out 
+        the actual calculation in case we want to coalesce calls to pruneSlowCase in the future.
+        (JSC::CodeCacheMap::prune): Check the number of entries against our hard cap. If it's greater than
+        the cap then we need to drop down to pruneSlowCase.
+
 2013-03-28  Zan Dobersek  <zdobersek@igalia.com>
 

trunk/Source/JavaScriptCore/runtime/CodeCache.cpp

@@ -48 +48 @@
         m_capacity = m_minCapacity;
 
-    while (m_size > m_capacity) {
+    while (m_size > m_capacity || !canPruneQuickly()) {
         MapType::iterator it = m_map.begin();
         m_size -= it->key.length();

trunk/Source/JavaScriptCore/runtime/CodeCache.h

@@ -197 +197 @@
     // working set to enter the cache before it starts evicting.
     static const double workingSetTime;
-    static const int64_t workingSetMax = 16000000;
+    static const int64_t workingSetMaxBytes = 16000000;
+    static const size_t workingSetMaxEntries = 2000;
 
     // This constant factor biases cache capacity toward recent activity. We
@@ -208 +209 @@
     static const int64_t oldObjectSamplingMultiplier = 32;
 
+    size_t numberOfEntries() const { return static_cast<size_t>(m_map.size()); }
+    bool canPruneQuickly() const { return numberOfEntries() < workingSetMaxEntries; }
+
     void pruneSlowCase();
     void prune()
     {
-        if (m_size <= m_capacity)
+        if (m_size <= m_capacity && canPruneQuickly())
             return;
 
         if (monotonicallyIncreasingTime() - m_timeAtLastPrune < workingSetTime
-            && m_size - m_sizeAtLastPrune < workingSetMax)
+            && m_size - m_sizeAtLastPrune < workingSetMaxBytes
+            && canPruneQuickly())
                 return;