When navigating, discard decoded image data that is only live due to page cache.
[WebKit-https.git] / Source / WebCore / platform / MemoryPressureHandler.cpp
1 /*
2  * Copyright (C) 2011-2016 Apple Inc. All Rights Reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "MemoryPressureHandler.h"
28
29 #include "CSSValuePool.h"
30 #include "CachedImage.h"
31 #include "Chrome.h"
32 #include "ChromeClient.h"
33 #include "Document.h"
34 #include "FontCache.h"
35 #include "GCController.h"
36 #include "HTMLMediaElement.h"
37 #include "InspectorInstrumentation.h"
38 #include "MemoryCache.h"
39 #include "Page.h"
40 #include "PageCache.h"
41 #include "ScrollingThread.h"
42 #include "StyledElement.h"
43 #include "WorkerThread.h"
44 #include <JavaScriptCore/IncrementalSweeper.h>
45 #include <chrono>
46 #include <wtf/CurrentTime.h>
47 #include <wtf/FastMalloc.h>
48 #include <wtf/StdLibExtras.h>
49
50 namespace WebCore {
51
52 WEBCORE_EXPORT bool MemoryPressureHandler::ReliefLogger::s_loggingEnabled = false;
53
54 MemoryPressureHandler& MemoryPressureHandler::singleton()
55 {
56     static NeverDestroyed<MemoryPressureHandler> memoryPressureHandler;
57     return memoryPressureHandler;
58 }
59
60 MemoryPressureHandler::MemoryPressureHandler() 
61     : m_installed(false)
62     , m_lastRespondTime(0)
63     , m_lowMemoryHandler([this] (Critical critical, Synchronous synchronous) { releaseMemory(critical, synchronous); })
64     , m_underMemoryPressure(false)
65 #if PLATFORM(IOS)
66     // FIXME: Can we share more of this with OpenSource?
67     , m_memoryPressureReason(MemoryPressureReasonNone)
68     , m_clearPressureOnMemoryRelease(true)
69     , m_releaseMemoryBlock(0)
70     , m_observer(0)
71 #elif OS(LINUX)
72     , m_eventFD(0)
73     , m_pressureLevelFD(0)
74     , m_threadID(0)
75     , m_holdOffTimer(*this, &MemoryPressureHandler::holdOffTimerFired)
76 #endif
77 {
78     platformInitialize();
79 }
80
81 void MemoryPressureHandler::releaseNoncriticalMemory()
82 {
83     {
84         ReliefLogger log("Purge inactive FontData");
85         FontCache::singleton().purgeInactiveFontData();
86     }
87
88     {
89         ReliefLogger log("Clear WidthCaches");
90         clearWidthCaches();
91     }
92
93     {
94         ReliefLogger log("Discard Selector Query Cache");
95         for (auto* document : Document::allDocuments())
96             document->clearSelectorQueryCache();
97     }
98
99     {
100         ReliefLogger log("Prune MemoryCache dead resources");
101         MemoryCache::singleton().pruneDeadResourcesToSize(0);
102     }
103
104     {
105         ReliefLogger log("Prune presentation attribute cache");
106         StyledElement::clearPresentationAttributeCache();
107     }
108 }
109
110 void MemoryPressureHandler::releaseCriticalMemory(Synchronous synchronous)
111 {
112     {
113         ReliefLogger log("Empty the PageCache");
114         // Right now, the only reason we call release critical memory while not under memory pressure is if the process is about to be suspended.
115         PruningReason pruningReason = isUnderMemoryPressure() ? PruningReason::MemoryPressure : PruningReason::ProcessSuspended;
116         PageCache::singleton().pruneToSizeNow(0, pruningReason);
117     }
118
119     {
120         ReliefLogger log("Prune MemoryCache live resources");
121         MemoryCache::singleton().pruneLiveResourcesToSize(0, /*shouldDestroyDecodedDataForAllLiveResources*/ true);
122     }
123
124     {
125         ReliefLogger log("Drain CSSValuePool");
126         CSSValuePool::singleton().drain();
127     }
128
129     {
130         ReliefLogger log("Discard StyleResolvers");
131         Vector<RefPtr<Document>> documents;
132         copyToVector(Document::allDocuments(), documents);
133         for (auto& document : documents)
134             document->clearStyleResolver();
135     }
136
137     {
138         ReliefLogger log("Discard all JIT-compiled code");
139         GCController::singleton().deleteAllCode();
140     }
141
142 #if ENABLE(VIDEO)
143     {
144         ReliefLogger log("Dropping buffered data from paused media elements");
145         for (auto* mediaElement: HTMLMediaElement::allMediaElements()) {
146             if (mediaElement->paused())
147                 mediaElement->purgeBufferedDataIfPossible();
148         }
149     }
150 #endif
151
152     if (synchronous == Synchronous::Yes) {
153         ReliefLogger log("Collecting JavaScript garbage");
154         GCController::singleton().garbageCollectNow();
155     } else
156         GCController::singleton().garbageCollectNowIfNotDoneRecently();
157
158     // We reduce tiling coverage while under memory pressure, so make sure to drop excess tiles ASAP.
159     Page::forEachPage([](Page& page) {
160         page.chrome().client().scheduleCompositingLayerFlush();
161     });
162 }
163
164 void MemoryPressureHandler::jettisonExpensiveObjectsOnTopLevelNavigation()
165 {
166     // Protect against doing excessive jettisoning during repeated navigations.
167     const auto minimumTimeSinceNavigation = 2s;
168
169     static auto timeOfLastNavigation = std::chrono::steady_clock::now();
170     auto now = std::chrono::steady_clock::now();
171     bool shouldJettison = now - timeOfLastNavigation >= minimumTimeSinceNavigation;
172     timeOfLastNavigation = now;
173
174     if (!shouldJettison)
175         return;
176
177     MemoryCache::singleton().forEachResource([](CachedResource& resource) {
178         if (resource.isImage()
179             && resource.decodedSize()
180             && downcast<CachedImage>(resource).areAllClientsInPageCache()) {
181             resource.destroyDecodedData();
182         }
183     });
184
185 #if PLATFORM(IOS)
186     // Throw away linked JS code. Linked code is tied to a global object and is not reusable.
187     // The immediate memory savings outweigh the cost of recompilation in case we go back again.
188     GCController::singleton().deleteAllLinkedCode();
189 #endif
190 }
191
192 void MemoryPressureHandler::releaseMemory(Critical critical, Synchronous synchronous)
193 {
194     if (critical == Critical::Yes)
195         releaseCriticalMemory(synchronous);
196
197     releaseNoncriticalMemory();
198
199     platformReleaseMemory(critical);
200
201     {
202         ReliefLogger log("Release free FastMalloc memory");
203         // FastMalloc has lock-free thread specific caches that can only be cleared from the thread itself.
204         WorkerThread::releaseFastMallocFreeMemoryInAllThreads();
205 #if ENABLE(ASYNC_SCROLLING) && !PLATFORM(IOS)
206         ScrollingThread::dispatch([]() {
207             WTF::releaseFastMallocFreeMemory();
208         });
209 #endif
210         WTF::releaseFastMallocFreeMemory();
211     }
212
213 #if ENABLE(RESOURCE_USAGE)
214     Page::forEachPage([&](Page& page) {
215         InspectorInstrumentation::didHandleMemoryPressure(page, critical);
216     });
217 #endif
218 }
219
220 void MemoryPressureHandler::ReliefLogger::logMemoryUsageChange()
221 {
222 #if !LOG_ALWAYS_DISABLED
223 #define STRING_SPECIFICATION "%{public}s"
224 #define MEMORYPRESSURE_LOG(...) LOG_ALWAYS(true, __VA_ARGS__)
225 #else
226 #define STRING_SPECIFICATION "%s"
227 #define MEMORYPRESSURE_LOG(...) WTFLogAlways(__VA_ARGS__)
228 #endif
229
230     size_t currentMemory = platformMemoryUsage();
231     if (currentMemory == static_cast<size_t>(-1) || m_initialMemory == static_cast<size_t>(-1)) {
232         MEMORYPRESSURE_LOG("Memory pressure relief: " STRING_SPECIFICATION ": (Unable to get dirty memory information for process)", m_logString);
233         return;
234     }
235
236     long memoryDiff = currentMemory - m_initialMemory;
237     if (memoryDiff < 0)
238         MEMORYPRESSURE_LOG("Memory pressure relief: " STRING_SPECIFICATION ": -dirty %ld bytes (from %zu to %zu)", m_logString, (memoryDiff * -1), m_initialMemory, currentMemory);
239     else if (memoryDiff > 0)
240         MEMORYPRESSURE_LOG("Memory pressure relief: " STRING_SPECIFICATION ": +dirty %ld bytes (from %zu to %zu)", m_logString, memoryDiff, m_initialMemory, currentMemory);
241     else
242         MEMORYPRESSURE_LOG("Memory pressure relief: " STRING_SPECIFICATION ": =dirty (at %zu bytes)", m_logString, currentMemory);
243 }
244
245 #if !PLATFORM(COCOA)
246 void MemoryPressureHandler::platformInitialize() { }
247 #endif
248
249 #if !PLATFORM(COCOA) && !OS(LINUX) && !PLATFORM(WIN)
250 void MemoryPressureHandler::install() { }
251 void MemoryPressureHandler::uninstall() { }
252 void MemoryPressureHandler::holdOff(unsigned) { }
253 void MemoryPressureHandler::respondToMemoryPressure(Critical, Synchronous) { }
254 void MemoryPressureHandler::platformReleaseMemory(Critical) { }
255 size_t MemoryPressureHandler::ReliefLogger::platformMemoryUsage() { return 0; }
256 #endif
257
258 } // namespace WebCore