[WTF] Move currentCPUTime and sleep(Seconds) to CPUTime.h and Seconds.h respectively
[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/MemoryPressureHandler.h>
35 #include <wtf/NeverDestroyed.h>
36
37 namespace WebCore {
38
39 static const Seconds capacityDecayTime { 5_s };
40
41 LegacyTileLayerPool::LegacyTileLayerPool()
42     : m_totalBytes(0)
43     , m_capacity(0)
44     , m_needsPrune(false)
45 {
46 }
47
48 LegacyTileLayerPool* LegacyTileLayerPool::sharedPool()
49 {
50     static NeverDestroyed<LegacyTileLayerPool> sharedPool;
51     return &sharedPool.get();
52 }
53
54 unsigned LegacyTileLayerPool::bytesBackingLayerWithPixelSize(const IntSize& size)
55 {
56     return (size.area() * 4).unsafeGet();
57 }
58
59 LegacyTileLayerPool::LayerList& LegacyTileLayerPool::listOfLayersWithSize(const IntSize& size, AccessType accessType)
60 {
61     ASSERT(!m_layerPoolMutex.tryLock());
62     HashMap<IntSize, LayerList>::iterator it = m_reuseLists.find(size);
63     if (it == m_reuseLists.end()) {
64         it = m_reuseLists.add(size, LayerList()).iterator;
65         m_sizesInPruneOrder.append(size);
66     } else if (accessType == MarkAsUsed) {
67         m_sizesInPruneOrder.remove(m_sizesInPruneOrder.reverseFind(size));
68         m_sizesInPruneOrder.append(size);
69     }
70     return it->value;
71 }
72
73 void LegacyTileLayerPool::addLayer(const RetainPtr<LegacyTileLayer>& layer)
74 {
75     IntSize layerSize([layer.get() frame].size);
76     layerSize.scale([layer.get() contentsScale]);
77     if (!canReuseLayerWithSize(layerSize))
78         return;
79
80     if (MemoryPressureHandler::singleton().isUnderMemoryPressure()) {
81         LOG(MemoryPressure, "Under memory pressure: %s, totalBytes: %d", __PRETTY_FUNCTION__, m_totalBytes);
82         return;
83     }
84
85     LockHolder locker(m_layerPoolMutex);
86     listOfLayersWithSize(layerSize).prepend(layer);
87     m_totalBytes += bytesBackingLayerWithPixelSize(layerSize);
88
89     m_lastAddTime = WallTime::now();
90     schedulePrune();
91 }
92
93 RetainPtr<LegacyTileLayer> LegacyTileLayerPool::takeLayerWithSize(const IntSize& size)
94 {
95     if (!canReuseLayerWithSize(size))
96         return nil;
97     LockHolder locker(m_layerPoolMutex);
98     LayerList& reuseList = listOfLayersWithSize(size, MarkAsUsed);
99     if (reuseList.isEmpty())
100         return nil;
101     m_totalBytes -= bytesBackingLayerWithPixelSize(size);
102     return reuseList.takeFirst();
103 }
104
105 void LegacyTileLayerPool::setCapacity(unsigned capacity)
106 {
107     LockHolder reuseLocker(m_layerPoolMutex);
108     if (capacity < m_capacity)
109         schedulePrune();
110     m_capacity = capacity;
111 }
112     
113 unsigned LegacyTileLayerPool::decayedCapacity() const
114 {
115     // Decay to one quarter over capacityDecayTime
116     Seconds timeSinceLastAdd = WallTime::now() - m_lastAddTime;
117     if (timeSinceLastAdd > capacityDecayTime)
118         return m_capacity / 4;
119     float decayProgess = float(timeSinceLastAdd / capacityDecayTime);
120     return m_capacity / 4 + m_capacity * 3 / 4 * (1.f - decayProgess);
121 }
122
123 void LegacyTileLayerPool::schedulePrune()
124 {
125     ASSERT(!m_layerPoolMutex.tryLock());
126     if (m_needsPrune)
127         return;
128     m_needsPrune = true;
129     dispatch_time_t nextPruneTime = dispatch_time(DISPATCH_TIME_NOW, 1 * NSEC_PER_SEC);
130     dispatch_after(nextPruneTime, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
131         prune();
132     });
133 }
134
135 void LegacyTileLayerPool::prune()
136 {
137     LockHolder locker(m_layerPoolMutex);
138     ASSERT(m_needsPrune);
139     m_needsPrune = false;
140     unsigned shrinkTo = decayedCapacity();
141     while (m_totalBytes > shrinkTo) {
142         ASSERT(!m_sizesInPruneOrder.isEmpty());
143         IntSize sizeToDrop = m_sizesInPruneOrder.first();
144         LayerList& oldestReuseList = m_reuseLists.find(sizeToDrop)->value;
145         if (oldestReuseList.isEmpty()) {
146             m_reuseLists.remove(sizeToDrop);
147             m_sizesInPruneOrder.remove(0);
148             continue;
149         }
150 #if LOG_TILING
151         NSLog(@"dropping layer of size %d x %d", sizeToDrop.width(), sizeToDrop.height());
152 #endif
153         m_totalBytes -= bytesBackingLayerWithPixelSize(sizeToDrop);
154         // The last element in the list is the oldest, hence most likely not to
155         // still have a backing store.
156         oldestReuseList.removeLast();
157     }
158     if (WallTime::now() - m_lastAddTime <= capacityDecayTime)
159         schedulePrune();
160 }
161
162 void LegacyTileLayerPool::drain()
163 {
164     LockHolder reuseLocker(m_layerPoolMutex);
165     m_reuseLists.clear();
166     m_sizesInPruneOrder.clear();
167     m_totalBytes = 0;
168 }
169
170 } // namespace WebCore
171
172 #endif // PLATFORM(IOS)