Source/WebCore/platform/graphics/cg/IOSurfacePool.cpp

   1 /*
   2  * Copyright (C) 2013, 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. 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 "IOSurfacePool.h"
  28
  29 #if USE(IOSURFACE)
  30
  31 #include "GraphicsContextCG.h"
  32 #include "IOSurface.h"
  33 #include <CoreGraphics/CoreGraphics.h>
  34 #include <chrono>
  35 #include <wtf/NeverDestroyed.h>
  36
  37 const std::chrono::milliseconds collectionInterval = 500_ms;
  38 const std::chrono::seconds surfaceAgeBeforeMarkingPurgeable = 2_s;
  39 const size_t defaultMaximumBytesCached = 1024 * 1024 * 64;
  40
  41 // We'll never allow more than 1/2 of the cache to be filled with in-use surfaces, because
  42 // they can't be immediately returned when requested (but will be freed up in the future).
  43 const size_t maximumInUseBytes = defaultMaximumBytesCached / 2;
  44
  45 #define ENABLE_IOSURFACE_POOL_STATISTICS false
  46 #if ENABLE_IOSURFACE_POOL_STATISTICS
  47 #define DUMP_POOL_STATISTICS() do { showPoolStatistics(); } while (0);
  48 #else
  49 #define DUMP_POOL_STATISTICS() ((void)0)
  50 #endif
  51
  52 namespace WebCore {
  53
  54 IOSurfacePool::IOSurfacePool()
  55     : m_collectionTimer(this, &IOSurfacePool::collectionTimerFired)
  56     , m_bytesCached(0)
  57     , m_inUseBytesCached(0)
  58     , m_maximumBytesCached(defaultMaximumBytesCached)
  59 {
  60 }
  61
  62 IOSurfacePool& IOSurfacePool::sharedPool()
  63 {
  64     static NeverDestroyed<IOSurfacePool> pool;
  65     return pool;
  66 }
  67
  68 static bool surfaceMatchesParameters(IOSurface& surface, const IntSize& requestedSize, ColorSpace colorSpace)
  69 {
  70     IntSize surfaceSize = surface.size();
  71     if (colorSpace != surface.colorSpace())
  72         return false;
  73     if (surfaceSize != requestedSize)
  74         return false;
  75     return true;
  76 }
  77
  78 void IOSurfacePool::willAddSurface(IOSurface* surface, bool inUse)
  79 {
  80     CachedSurfaceDetails& details = m_surfaceDetails.add(surface, CachedSurfaceDetails()).iterator->value;
  81     details.resetLastUseTime();
  82
  83     surface->releaseGraphicsContext();
  84
  85     size_t surfaceBytes = surface->totalBytes();
  86
  87     evict(surfaceBytes);
  88
  89     m_bytesCached += surfaceBytes;
  90     if (inUse)
  91         m_inUseBytesCached += surfaceBytes;
  92 }
  93
  94 void IOSurfacePool::didRemoveSurface(IOSurface* surface, bool inUse)
  95 {
  96     size_t surfaceBytes = surface->totalBytes();
  97     m_bytesCached -= surfaceBytes;
  98     if (inUse)
  99         m_inUseBytesCached -= surfaceBytes;
 100
 101     m_surfaceDetails.remove(surface);
 102 }
 103
 104 void IOSurfacePool::didUseSurfaceOfSize(IntSize size)
 105 {
 106     m_sizesInPruneOrder.remove(m_sizesInPruneOrder.reverseFind(size));
 107     m_sizesInPruneOrder.append(size);
 108 }
 109
 110 PassRefPtr<IOSurface> IOSurfacePool::takeSurface(IntSize size, ColorSpace colorSpace)
 111 {
 112     CachedSurfaceMap::iterator mapIter = m_cachedSurfaces.find(size);
 113
 114     if (mapIter == m_cachedSurfaces.end()) {
 115         DUMP_POOL_STATISTICS();
 116         return nullptr;
 117     }
 118
 119     for (auto surfaceIter = mapIter->value.begin(); surfaceIter != mapIter->value.end(); ++surfaceIter) {
 120         if (!surfaceMatchesParameters(*surfaceIter->get(), size, colorSpace))
 121             continue;
 122
 123         RefPtr<IOSurface> surface = surfaceIter->get();
 124         mapIter->value.remove(surfaceIter);
 125
 126         didUseSurfaceOfSize(size);
 127
 128         if (mapIter->value.isEmpty()) {
 129             m_cachedSurfaces.remove(mapIter);
 130             m_sizesInPruneOrder.removeLast();
 131         }
 132
 133         didRemoveSurface(surface.get(), false);
 134
 135         surface->setIsVolatile(false);
 136
 137         DUMP_POOL_STATISTICS();
 138         return surface.release();
 139     }
 140
 141     // Some of the in-use surfaces may no longer actually be in-use, but we haven't moved them over yet.
 142     for (auto surfaceIter = m_inUseSurfaces.begin(); surfaceIter != m_inUseSurfaces.end(); ++surfaceIter) {
 143         if (!surfaceMatchesParameters(*surfaceIter->get(), size, colorSpace))
 144             continue;
 145         if (surfaceIter->get()->isInUse())
 146             continue;
 147
 148         RefPtr<IOSurface> surface = surfaceIter->get();
 149         m_inUseSurfaces.remove(surfaceIter);
 150         didRemoveSurface(surface.get(), true);
 151
 152         surface->setIsVolatile(false);
 153
 154         DUMP_POOL_STATISTICS();
 155         return surface.release();
 156     }
 157
 158     DUMP_POOL_STATISTICS();
 159     return nullptr;
 160 }
 161
 162 void IOSurfacePool::addSurface(IOSurface* surface)
 163 {
 164     if (surface->totalBytes() > m_maximumBytesCached)
 165         return;
 166
 167     bool surfaceIsInUse = surface->isInUse();
 168
 169     willAddSurface(surface, surfaceIsInUse);
 170
 171     if (surfaceIsInUse) {
 172         m_inUseSurfaces.prepend(surface);
 173         scheduleCollectionTimer();
 174         DUMP_POOL_STATISTICS();
 175         return;
 176     }
 177
 178     insertSurfaceIntoPool(surface);
 179     DUMP_POOL_STATISTICS();
 180 }
 181
 182 void IOSurfacePool::insertSurfaceIntoPool(IOSurface* surface)
 183 {
 184     auto insertedTuple = m_cachedSurfaces.add(surface->size(), CachedSurfaceQueue());
 185     insertedTuple.iterator->value.prepend(surface);
 186     if (!insertedTuple.isNewEntry)
 187         m_sizesInPruneOrder.remove(m_sizesInPruneOrder.reverseFind(surface->size()));
 188     m_sizesInPruneOrder.append(surface->size());
 189
 190     scheduleCollectionTimer();
 191 }
 192
 193 void IOSurfacePool::setPoolSize(size_t poolSizeInBytes)
 194 {
 195     m_maximumBytesCached = poolSizeInBytes;
 196     evict(0);
 197 }
 198
 199 void IOSurfacePool::tryEvictInUseSurface()
 200 {
 201     if (m_inUseSurfaces.isEmpty())
 202         return;
 203
 204     RefPtr<IOSurface> surface = m_inUseSurfaces.takeLast();
 205     didRemoveSurface(surface.get(), true);
 206 }
 207
 208 void IOSurfacePool::tryEvictOldestCachedSurface()
 209 {
 210     if (m_cachedSurfaces.isEmpty())
 211         return;
 212
 213     if (m_sizesInPruneOrder.isEmpty())
 214         return;
 215
 216     CachedSurfaceMap::iterator surfaceQueueIter = m_cachedSurfaces.find(m_sizesInPruneOrder.first());
 217     ASSERT(!surfaceQueueIter->value.isEmpty());
 218     RefPtr<IOSurface> surface = surfaceQueueIter->value.takeLast();
 219     didRemoveSurface(surface.get(), false);
 220
 221     if (surfaceQueueIter->value.isEmpty()) {
 222         m_cachedSurfaces.remove(surfaceQueueIter);
 223         m_sizesInPruneOrder.remove(0);
 224     }
 225 }
 226
 227 void IOSurfacePool::evict(size_t additionalSize)
 228 {
 229     if (additionalSize >= m_maximumBytesCached) {
 230         discardAllSurfaces();
 231         return;
 232     }
 233
 234     // FIXME: Perhaps purgeable surfaces should count less against the cap?
 235     // We don't want to end up with a ton of empty (purged) surfaces, though, as that would defeat the purpose of the pool.
 236     size_t targetSize = m_maximumBytesCached - additionalSize;
 237
 238     // Interleave eviction of old cached surfaces and more recent in-use surfaces.
 239     // In-use surfaces are more recently used, but less useful in the pool, as they aren't
 240     // immediately available when requested.
 241     while (m_bytesCached > targetSize) {
 242         tryEvictOldestCachedSurface();
 243
 244         if (m_inUseBytesCached > maximumInUseBytes || m_bytesCached > targetSize)
 245             tryEvictInUseSurface();
 246     }
 247
 248     while (m_inUseBytesCached > maximumInUseBytes || m_bytesCached > targetSize)
 249         tryEvictInUseSurface();
 250 }
 251
 252 void IOSurfacePool::collectInUseSurfaces()
 253 {
 254     CachedSurfaceQueue newInUseSurfaces;
 255     for (CachedSurfaceQueue::iterator surfaceIter = m_inUseSurfaces.begin(); surfaceIter != m_inUseSurfaces.end(); ++surfaceIter) {
 256         IOSurface* surface = surfaceIter->get();
 257         if (surface->isInUse()) {
 258             newInUseSurfaces.append(*surfaceIter);
 259             continue;
 260         }
 261
 262         m_inUseBytesCached -= surface->totalBytes();
 263         insertSurfaceIntoPool(surface);
 264     }
 265
 266     m_inUseSurfaces = newInUseSurfaces;
 267 }
 268
 269 bool IOSurfacePool::markOlderSurfacesPurgeable()
 270 {
 271     bool markedAllSurfaces = true;
 272     auto markTime = std::chrono::steady_clock::now();
 273
 274     for (auto& surfaceAndDetails : m_surfaceDetails) {
 275         if (surfaceAndDetails.value.hasMarkedPurgeable)
 276             continue;
 277
 278         if (markTime - surfaceAndDetails.value.lastUseTime < surfaceAgeBeforeMarkingPurgeable) {
 279             markedAllSurfaces = false;
 280             continue;
 281         }
 282
 283         surfaceAndDetails.key->setIsVolatile(true);
 284         surfaceAndDetails.value.hasMarkedPurgeable = true;
 285     }
 286
 287     return markedAllSurfaces;
 288 }
 289
 290 void IOSurfacePool::collectionTimerFired(Timer<IOSurfacePool>&)
 291 {
 292     collectInUseSurfaces();
 293     bool markedAllSurfaces = markOlderSurfacesPurgeable();
 294
 295     if (!m_inUseSurfaces.size() && markedAllSurfaces)
 296         m_collectionTimer.stop();
 297
 298     platformGarbageCollectNow();
 299     DUMP_POOL_STATISTICS();
 300 }
 301
 302 void IOSurfacePool::scheduleCollectionTimer()
 303 {
 304     if (!m_collectionTimer.isActive())
 305         m_collectionTimer.startRepeating(collectionInterval);
 306 }
 307
 308 void IOSurfacePool::discardAllSurfaces()
 309 {
 310     m_bytesCached = 0;
 311     m_inUseBytesCached = 0;
 312     m_surfaceDetails.clear();
 313     m_cachedSurfaces.clear();
 314     m_inUseSurfaces.clear();
 315     m_sizesInPruneOrder.clear();
 316     m_collectionTimer.stop();
 317     platformGarbageCollectNow();
 318 }
 319
 320 void IOSurfacePool::showPoolStatistics()
 321 {
 322 #if ENABLE_IOSURFACE_POOL_STATISTICS
 323     WTFLogAlways("IOSurfacePool Statistics\n");
 324     unsigned totalSurfaces = 0;
 325     size_t totalSize = 0;
 326     size_t totalPurgeableSize = 0;
 327
 328     for (const auto& keyAndSurfaces : m_cachedSurfaces) {
 329         ASSERT(!keyAndSurfaces.value.isEmpty());
 330         size_t queueSize = 0;
 331         size_t queuePurgeableSize = 0;
 332         for (const auto& surface : keyAndSurfaces.value) {
 333             size_t surfaceBytes = surface->totalBytes();
 334
 335             totalSurfaces++;
 336             queueSize += surfaceBytes;
 337
 338             if (surface->isVolatile())
 339                 queuePurgeableSize += surfaceBytes;
 340         }
 341
 342         totalSize += queueSize;
 343         totalPurgeableSize += queuePurgeableSize;
 344
 345         WTFLogAlways("   %d x %d: %zu surfaces for %zd KB (%zd KB purgeable)", keyAndSurfaces.key.width(), keyAndSurfaces.key.height(), keyAndSurfaces.value.size(), queueSize / 1024, queuePurgeableSize / 1024);
 346     }
 347
 348     size_t inUseSize = 0;
 349     for (const auto& surface : m_inUseSurfaces) {
 350         totalSurfaces++;
 351         inUseSize += surface->totalBytes();
 352     }
 353
 354     totalSize += inUseSize;
 355     WTFLogAlways("   IN USE: %zu surfaces for %zd KB", m_inUseSurfaces.size(), inUseSize / 1024);
 356
 357     // FIXME: Should move consistency checks elsewhere, and always perform them in debug builds.
 358     ASSERT(m_bytesCached == totalSize);
 359     ASSERT(m_bytesCached <= m_maximumBytesCached);
 360
 361     WTFLogAlways("   TOTAL: %d surfaces for %zd KB (%zd KB purgeable)\n", totalSurfaces, totalSize / 1024, totalPurgeableSize / 1024);
 362 #endif
 363 }
 364
 365 }
 366 #endif // USE(IOSURFACE)