Update ANGLE
[WebKit-https.git] / Source / WebCore / platform / MemoryPressureHandler.cpp
1 /*
2  * Copyright (C) 2011, 2014 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 "Chrome.h"
31 #include "ChromeClient.h"
32 #include "Document.h"
33 #include "FontCache.h"
34 #include "GCController.h"
35 #include "HTMLMediaElement.h"
36 #include "InlineStyleSheetOwner.h"
37 #include "InspectorInstrumentation.h"
38 #include "Logging.h"
39 #include "MemoryCache.h"
40 #include "Page.h"
41 #include "PageCache.h"
42 #include "ScrollingThread.h"
43 #include "StyleScope.h"
44 #include "StyledElement.h"
45 #include "WorkerThread.h"
46 #include <JavaScriptCore/IncrementalSweeper.h>
47 #include <chrono>
48 #include <wtf/CurrentTime.h>
49 #include <wtf/FastMalloc.h>
50 #include <wtf/StdLibExtras.h>
51
52 namespace WebCore {
53
54 WEBCORE_EXPORT bool MemoryPressureHandler::ReliefLogger::s_loggingEnabled = false;
55
56 MemoryPressureHandler& MemoryPressureHandler::singleton()
57 {
58     static NeverDestroyed<MemoryPressureHandler> memoryPressureHandler;
59     return memoryPressureHandler;
60 }
61
62 MemoryPressureHandler::MemoryPressureHandler() 
63     : m_installed(false)
64     , m_lastRespondTime(0)
65     , m_lowMemoryHandler([this] (Critical critical, Synchronous synchronous) { releaseMemory(critical, synchronous); })
66     , m_underMemoryPressure(false)
67 #if PLATFORM(IOS)
68     // FIXME: Can we share more of this with OpenSource?
69     , m_memoryPressureReason(MemoryPressureReasonNone)
70     , m_clearPressureOnMemoryRelease(true)
71     , m_releaseMemoryBlock(0)
72     , m_observer(0)
73 #elif OS(LINUX)
74     , m_holdOffTimer(RunLoop::main(), this, &MemoryPressureHandler::holdOffTimerFired)
75 #endif
76 {
77     platformInitialize();
78 }
79
80 void MemoryPressureHandler::releaseNoncriticalMemory()
81 {
82     {
83         ReliefLogger log("Purge inactive FontData");
84         FontCache::singleton().purgeInactiveFontData();
85     }
86
87     {
88         ReliefLogger log("Clear WidthCaches");
89         clearWidthCaches();
90     }
91
92     {
93         ReliefLogger log("Discard Selector Query Cache");
94         for (auto* document : Document::allDocuments())
95             document->clearSelectorQueryCache();
96     }
97
98     {
99         ReliefLogger log("Prune MemoryCache dead resources");
100         MemoryCache::singleton().pruneDeadResourcesToSize(0);
101     }
102
103     {
104         ReliefLogger log("Prune presentation attribute cache");
105         StyledElement::clearPresentationAttributeCache();
106     }
107
108     {
109         ReliefLogger log("Clear inline stylesheet cache");
110         InlineStyleSheetOwner::clearCache();
111     }
112 }
113
114 void MemoryPressureHandler::releaseCriticalMemory(Synchronous synchronous)
115 {
116     {
117         ReliefLogger log("Empty the PageCache");
118         // Right now, the only reason we call release critical memory while not under memory pressure is if the process is about to be suspended.
119         PruningReason pruningReason = isUnderMemoryPressure() ? PruningReason::MemoryPressure : PruningReason::ProcessSuspended;
120         PageCache::singleton().pruneToSizeNow(0, pruningReason);
121     }
122
123     {
124         ReliefLogger log("Prune MemoryCache live resources");
125         MemoryCache::singleton().pruneLiveResourcesToSize(0, /*shouldDestroyDecodedDataForAllLiveResources*/ true);
126     }
127
128     {
129         ReliefLogger log("Drain CSSValuePool");
130         CSSValuePool::singleton().drain();
131     }
132
133     {
134         ReliefLogger log("Discard StyleResolvers");
135         Vector<RefPtr<Document>> documents;
136         copyToVector(Document::allDocuments(), documents);
137         for (auto& document : documents)
138             document->styleScope().clearResolver();
139     }
140
141     {
142         ReliefLogger log("Discard all JIT-compiled code");
143         GCController::singleton().deleteAllCode();
144     }
145
146 #if ENABLE(VIDEO)
147     {
148         ReliefLogger log("Dropping buffered data from paused media elements");
149         for (auto* mediaElement: HTMLMediaElement::allMediaElements()) {
150             if (mediaElement->paused())
151                 mediaElement->purgeBufferedDataIfPossible();
152         }
153     }
154 #endif
155
156     if (synchronous == Synchronous::Yes) {
157         ReliefLogger log("Collecting JavaScript garbage");
158         GCController::singleton().garbageCollectNow();
159     } else
160         GCController::singleton().garbageCollectNowIfNotDoneRecently();
161
162     // We reduce tiling coverage while under memory pressure, so make sure to drop excess tiles ASAP.
163     Page::forEachPage([](Page& page) {
164         page.chrome().client().scheduleCompositingLayerFlush();
165     });
166 }
167
168 void MemoryPressureHandler::jettisonExpensiveObjectsOnTopLevelNavigation()
169 {
170 #if PLATFORM(IOS)
171     // Protect against doing excessive jettisoning during repeated navigations.
172     const auto minimumTimeSinceNavigation = 2s;
173
174     static auto timeOfLastNavigation = std::chrono::steady_clock::now();
175     auto now = std::chrono::steady_clock::now();
176     bool shouldJettison = now - timeOfLastNavigation >= minimumTimeSinceNavigation;
177     timeOfLastNavigation = now;
178
179     if (!shouldJettison)
180         return;
181
182     // Throw away linked JS code. Linked code is tied to a global object and is not reusable.
183     // The immediate memory savings outweigh the cost of recompilation in case we go back again.
184     GCController::singleton().deleteAllLinkedCode();
185 #endif
186 }
187
188 void MemoryPressureHandler::beginSimulatedMemoryPressure()
189 {
190     m_isSimulatingMemoryPressure = true;
191     MemoryPressureHandler::singleton().respondToMemoryPressure(Critical::Yes, Synchronous::Yes);
192 }
193
194 void MemoryPressureHandler::endSimulatedMemoryPressure()
195 {
196     m_isSimulatingMemoryPressure = false;
197 }
198
199 void MemoryPressureHandler::releaseMemory(Critical critical, Synchronous synchronous)
200 {
201     if (critical == Critical::Yes)
202         releaseCriticalMemory(synchronous);
203
204     releaseNoncriticalMemory();
205
206     platformReleaseMemory(critical);
207
208     {
209         ReliefLogger log("Release free FastMalloc memory");
210         // FastMalloc has lock-free thread specific caches that can only be cleared from the thread itself.
211         WorkerThread::releaseFastMallocFreeMemoryInAllThreads();
212 #if ENABLE(ASYNC_SCROLLING) && !PLATFORM(IOS)
213         ScrollingThread::dispatch([]() {
214             WTF::releaseFastMallocFreeMemory();
215         });
216 #endif
217         WTF::releaseFastMallocFreeMemory();
218     }
219
220 #if ENABLE(RESOURCE_USAGE)
221     Page::forEachPage([&](Page& page) {
222         InspectorInstrumentation::didHandleMemoryPressure(page, critical);
223     });
224 #endif
225 }
226
227 void MemoryPressureHandler::ReliefLogger::logMemoryUsageChange()
228 {
229 #if !RELEASE_LOG_DISABLED
230 #define STRING_SPECIFICATION "%{public}s"
231 #define MEMORYPRESSURE_LOG(...) RELEASE_LOG(MemoryPressure, __VA_ARGS__)
232 #else
233 #define STRING_SPECIFICATION "%s"
234 #define MEMORYPRESSURE_LOG(...) WTFLogAlways(__VA_ARGS__)
235 #endif
236
237     size_t currentMemory = platformMemoryUsage();
238     if (currentMemory == static_cast<size_t>(-1) || m_initialMemory == static_cast<size_t>(-1)) {
239         MEMORYPRESSURE_LOG("Memory pressure relief: " STRING_SPECIFICATION ": (Unable to get dirty memory information for process)", m_logString);
240         return;
241     }
242
243     long memoryDiff = currentMemory - m_initialMemory;
244     if (memoryDiff < 0)
245         MEMORYPRESSURE_LOG("Memory pressure relief: " STRING_SPECIFICATION ": -dirty %ld bytes (from %zu to %zu)", m_logString, (memoryDiff * -1), m_initialMemory, currentMemory);
246     else if (memoryDiff > 0)
247         MEMORYPRESSURE_LOG("Memory pressure relief: " STRING_SPECIFICATION ": +dirty %ld bytes (from %zu to %zu)", m_logString, memoryDiff, m_initialMemory, currentMemory);
248     else
249         MEMORYPRESSURE_LOG("Memory pressure relief: " STRING_SPECIFICATION ": =dirty (at %zu bytes)", m_logString, currentMemory);
250 }
251
252 #if !PLATFORM(COCOA)
253 void MemoryPressureHandler::platformInitialize() { }
254 #endif
255
256 #if !PLATFORM(COCOA) && !OS(LINUX) && !PLATFORM(WIN)
257 void MemoryPressureHandler::install() { }
258 void MemoryPressureHandler::uninstall() { }
259 void MemoryPressureHandler::holdOff(unsigned) { }
260 void MemoryPressureHandler::respondToMemoryPressure(Critical, Synchronous) { }
261 void MemoryPressureHandler::platformReleaseMemory(Critical) { }
262 size_t MemoryPressureHandler::ReliefLogger::platformMemoryUsage() { return 0; }
263 #endif
264
265 } // namespace WebCore