250028ff9aba8582237226d10dceec23a67f5a79
[WebKit-https.git] / Source / WebCore / platform / ios / LegacyTileLayerPool.mm
1 /*
2  * Copyright (C) 2011 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. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "LegacyTileLayerPool.h"
28
29 #if PLATFORM(IOS)
30
31 #include "LegacyTileLayer.h"
32 #include "LegacyTileGrid.h"
33 #include "Logging.h"
34 #include <wtf/CurrentTime.h>
35 #include <wtf/MemoryPressureHandler.h>
36 #include <wtf/NeverDestroyed.h>
37
38 namespace WebCore {
39
40 static const Seconds capacityDecayTime { 5_s };
41
42 LegacyTileLayerPool::LegacyTileLayerPool()
43     : m_totalBytes(0)
44     , m_capacity(0)
45     , m_needsPrune(false)
46 {
47 }
48
49 LegacyTileLayerPool* LegacyTileLayerPool::sharedPool()
50 {
51     static NeverDestroyed<LegacyTileLayerPool> sharedPool;
52     return &sharedPool.get();
53 }
54
55 unsigned LegacyTileLayerPool::bytesBackingLayerWithPixelSize(const IntSize& size)
56 {
57     return (size.area() * 4).unsafeGet();
58 }
59
60 LegacyTileLayerPool::LayerList& LegacyTileLayerPool::listOfLayersWithSize(const IntSize& size, AccessType accessType)
61 {
62     ASSERT(!m_layerPoolMutex.tryLock());
63     HashMap<IntSize, LayerList>::iterator it = m_reuseLists.find(size);
64     if (it == m_reuseLists.end()) {
65         it = m_reuseLists.add(size, LayerList()).iterator;
66         m_sizesInPruneOrder.append(size);
67     } else if (accessType == MarkAsUsed) {
68         m_sizesInPruneOrder.remove(m_sizesInPruneOrder.reverseFind(size));
69         m_sizesInPruneOrder.append(size);
70     }
71     return it->value;
72 }
73
74 void LegacyTileLayerPool::addLayer(const RetainPtr<LegacyTileLayer>& layer)
75 {
76     IntSize layerSize([layer.get() frame].size);
77     layerSize.scale([layer.get() contentsScale]);
78     if (!canReuseLayerWithSize(layerSize))
79         return;
80
81     if (MemoryPressureHandler::singleton().isUnderMemoryPressure()) {
82         LOG(MemoryPressure, "Under memory pressure: %s, totalBytes: %d", __PRETTY_FUNCTION__, m_totalBytes);
83         return;
84     }
85
86     LockHolder locker(m_layerPoolMutex);
87     listOfLayersWithSize(layerSize).prepend(layer);
88     m_totalBytes += bytesBackingLayerWithPixelSize(layerSize);
89
90     m_lastAddTime = WallTime::now();
91     schedulePrune();
92 }
93
94 RetainPtr<LegacyTileLayer> LegacyTileLayerPool::takeLayerWithSize(const IntSize& size)
95 {
96     if (!canReuseLayerWithSize(size))
97         return nil;
98     LockHolder locker(m_layerPoolMutex);
99     LayerList& reuseList = listOfLayersWithSize(size, MarkAsUsed);
100     if (reuseList.isEmpty())
101         return nil;
102     m_totalBytes -= bytesBackingLayerWithPixelSize(size);
103     return reuseList.takeFirst();
104 }
105
106 void LegacyTileLayerPool::setCapacity(unsigned capacity)
107 {
108     LockHolder reuseLocker(m_layerPoolMutex);
109     if (capacity < m_capacity)
110         schedulePrune();
111     m_capacity = capacity;
112 }
113     
114 unsigned LegacyTileLayerPool::decayedCapacity() const
115 {
116     // Decay to one quarter over capacityDecayTime
117     Seconds timeSinceLastAdd = WallTime::now() - m_lastAddTime;
118     if (timeSinceLastAdd > capacityDecayTime)
119         return m_capacity / 4;
120     float decayProgess = float(timeSinceLastAdd / capacityDecayTime);
121     return m_capacity / 4 + m_capacity * 3 / 4 * (1.f - decayProgess);
122 }
123
124 void LegacyTileLayerPool::schedulePrune()
125 {
126     ASSERT(!m_layerPoolMutex.tryLock());
127     if (m_needsPrune)
128         return;
129     m_needsPrune = true;
130     dispatch_time_t nextPruneTime = dispatch_time(DISPATCH_TIME_NOW, 1 * NSEC_PER_SEC);
131     dispatch_after(nextPruneTime, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
132         prune();
133     });
134 }
135
136 void LegacyTileLayerPool::prune()
137 {
138     LockHolder locker(m_layerPoolMutex);
139     ASSERT(m_needsPrune);
140     m_needsPrune = false;
141     unsigned shrinkTo = decayedCapacity();
142     while (m_totalBytes > shrinkTo) {
143         ASSERT(!m_sizesInPruneOrder.isEmpty());
144         IntSize sizeToDrop = m_sizesInPruneOrder.first();
145         LayerList& oldestReuseList = m_reuseLists.find(sizeToDrop)->value;
146         if (oldestReuseList.isEmpty()) {
147             m_reuseLists.remove(sizeToDrop);
148             m_sizesInPruneOrder.remove(0);
149             continue;
150         }
151 #if LOG_TILING
152         NSLog(@"dropping layer of size %d x %d", sizeToDrop.width(), sizeToDrop.height());
153 #endif
154         m_totalBytes -= bytesBackingLayerWithPixelSize(sizeToDrop);
155         // The last element in the list is the oldest, hence most likely not to
156         // still have a backing store.
157         oldestReuseList.removeLast();
158     }
159     if (WallTime::now() - m_lastAddTime <= capacityDecayTime)
160         schedulePrune();
161 }
162
163 void LegacyTileLayerPool::drain()
164 {
165     LockHolder reuseLocker(m_layerPoolMutex);
166     m_reuseLists.clear();
167     m_sizesInPruneOrder.clear();
168     m_totalBytes = 0;
169 }
170
171 } // namespace WebCore
172
173 #endif // PLATFORM(IOS)