Changeset 183194 in webkit

Timestamp:

Apr 23, 2015 10:48:37 AM (9 years ago)

Author:

Antti Koivisto

Message:

Memory cache live resources repeatedly purged during painting
​https://bugs.webkit.org/show_bug.cgi?id=144104
<rdar://problem/20667695>

Reviewed by Chris Dumez.

On some PLT pages (like nytimes.com) we get into state where painting repeatedly purges live bitmaps.
This slows down page loads significantly.

This might have regressed because improvements in page caching keep more pages and so resources 'live'.

With this path we do all regular cache pruning asynchronously. If memory is really critical
the low memory handling code will still prune synchronously.

• loader/cache/CachedResource.cpp:

(WebCore::CachedResource::removeClient):
(WebCore::CachedResource::didAccessDecodedData):

prune() -> pruneSoon()

• loader/cache/MemoryCache.cpp:

Decrease the pruning size target from 0.95 to 0.8 so we don't need to prune so often.

(WebCore::MemoryCache::needsPruning):

Factor into a function.

(WebCore::MemoryCache::prune):
(WebCore::MemoryCache::pruneSoon):

Prune asynchronously.

• loader/cache/MemoryCache.h:

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• loader/cache/CachedResource.cpp (modified) (2 diffs)
• loader/cache/MemoryCache.cpp (modified) (3 diffs)
• loader/cache/MemoryCache.h (modified) (3 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2015-04-23  Antti Koivisto  <antti@apple.com>
+
+        Memory cache live resources repeatedly purged during painting
+        https://bugs.webkit.org/show_bug.cgi?id=144104
+        <rdar://problem/20667695>
+
+        Reviewed by Chris Dumez.
+
+        On some PLT pages (like nytimes.com) we get into state where painting repeatedly purges live bitmaps.
+        This slows down page loads significantly.
+
+        This might have regressed because improvements in page caching keep more pages and so resources 'live'.
+
+        With this path we do all regular cache pruning asynchronously. If memory is really critical
+        the low memory handling code will still prune synchronously.
+
+        * loader/cache/CachedResource.cpp:
+        (WebCore::CachedResource::removeClient):
+        (WebCore::CachedResource::didAccessDecodedData):
+
+            prune() -> pruneSoon()
+
+        * loader/cache/MemoryCache.cpp:
+
+            Decrease the pruning size target from 0.95 to 0.8 so we don't need to prune so often.
+
+        (WebCore::MemoryCache::needsPruning):
+
+            Factor into a function.
+
+        (WebCore::MemoryCache::prune):
+        (WebCore::MemoryCache::pruneSoon):
+
+            Prune asynchronously.
+
+        * loader/cache/MemoryCache.h:
+
 2015-04-23  Eric Carlson  <eric.carlson@apple.com>
 

trunk/Source/WebCore/loader/cache/CachedResource.cpp

@@ -461 +461 @@
             memoryCache.remove(*this);
         }
-        memoryCache.prune();
+        memoryCache.pruneSoon();
     }
     // This object may be dead here.
@@ -558 +558 @@
             memoryCache.insertInLiveDecodedResourcesList(*this);
         }
-        memoryCache.prune();
+        memoryCache.pruneSoon();
     }
 }

trunk/Source/WebCore/loader/cache/MemoryCache.cpp

@@ -44 +44 @@
 #include <wtf/MathExtras.h>
 #include <wtf/NeverDestroyed.h>
+#include <wtf/RunLoop.h>
 #include <wtf/TemporaryChange.h>
 #include <wtf/text/CString.h>
@@ -51 +52 @@
 static const int cDefaultCacheCapacity = 8192 * 1024;
 static const double cMinDelayBeforeLiveDecodedPrune = 1; // Seconds.
-static const float cTargetPrunePercentage = .95f; // Percentage of capacity toward which we prune, to avoid immediately pruning again.
+static const float cTargetPrunePercentage = 0.8; // Percentage of capacity toward which we prune, to avoid immediately pruning again.
 static const auto defaultDecodedDataDeletionInterval = std::chrono::seconds { 0 };
 
@@ -746 +747 @@
 }
 
+bool MemoryCache::needsPruning() const
+{
+    return m_liveSize + m_deadSize > m_capacity || m_deadSize > m_maxDeadCapacity;
+}
+
 void MemoryCache::prune()
 {
-    if (m_liveSize + m_deadSize <= m_capacity && m_deadSize <= m_maxDeadCapacity) // Fast path.
-        return;
-        
+    if (!needsPruning())
+        return;
+
     pruneDeadResources(); // Prune dead first, in case it was "borrowing" capacity from live.
     pruneLiveResources();
+}
+
+void MemoryCache::pruneSoon()
+{
+    if (m_willPruneSoon)
+        return;
+    if (!needsPruning())
+        return;
+
+    m_willPruneSoon = true;
+    RunLoop::main().dispatch([this] {
+        prune();
+        m_willPruneSoon = false;
+    });
 }
 

trunk/Source/WebCore/loader/cache/MemoryCache.h

@@ -116 +116 @@
     WEBCORE_EXPORT void evictResources();
     WEBCORE_EXPORT void evictResources(SessionID);
-    
+
     void prune();
+    void pruneSoon();
     unsigned size() const { return m_liveSize + m_deadSize; }
 
@@ -185 +186 @@
     unsigned liveCapacity() const;
     unsigned deadCapacity() const;
+    bool needsPruning() const;
 
     CachedResource* resourceForRequestImpl(const ResourceRequest&, CachedResourceMap&);
@@ -214 +216 @@
     typedef HashMap<SessionID, std::unique_ptr<CachedResourceMap>> SessionCachedResourceMap;
     SessionCachedResourceMap m_sessionResources;
+
+    bool m_willPruneSoon { false };
 };