summaryrefslogtreecommitdiffstats
path: root/image/SurfaceCache.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'image/SurfaceCache.cpp')
-rw-r--r--image/SurfaceCache.cpp1164
1 files changed, 1164 insertions, 0 deletions
diff --git a/image/SurfaceCache.cpp b/image/SurfaceCache.cpp
new file mode 100644
index 000000000..66fdfcca0
--- /dev/null
+++ b/image/SurfaceCache.cpp
@@ -0,0 +1,1164 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * SurfaceCache is a service for caching temporary surfaces in imagelib.
+ */
+
+#include "SurfaceCache.h"
+
+#include <algorithm>
+#include "mozilla/Assertions.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/Likely.h"
+#include "mozilla/Move.h"
+#include "mozilla/Pair.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/StaticMutex.h"
+#include "mozilla/StaticPtr.h"
+#include "mozilla/Tuple.h"
+#include "nsIMemoryReporter.h"
+#include "gfx2DGlue.h"
+#include "gfxPlatform.h"
+#include "gfxPrefs.h"
+#include "imgFrame.h"
+#include "Image.h"
+#include "ISurfaceProvider.h"
+#include "LookupResult.h"
+#include "nsExpirationTracker.h"
+#include "nsHashKeys.h"
+#include "nsRefPtrHashtable.h"
+#include "nsSize.h"
+#include "nsTArray.h"
+#include "prsystem.h"
+#include "ShutdownTracker.h"
+
+using std::max;
+using std::min;
+
+namespace mozilla {
+
+using namespace gfx;
+
+namespace image {
+
+class CachedSurface;
+class SurfaceCacheImpl;
+
+///////////////////////////////////////////////////////////////////////////////
+// Static Data
+///////////////////////////////////////////////////////////////////////////////
+
+// The single surface cache instance.
+static StaticRefPtr<SurfaceCacheImpl> sInstance;
+
+// The mutex protecting the surface cache.
+static StaticMutex sInstanceMutex;
+
+///////////////////////////////////////////////////////////////////////////////
+// SurfaceCache Implementation
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Cost models the cost of storing a surface in the cache. Right now, this is
+ * simply an estimate of the size of the surface in bytes, but in the future it
+ * may be worth taking into account the cost of rematerializing the surface as
+ * well.
+ */
+typedef size_t Cost;
+
+static Cost
+ComputeCost(const IntSize& aSize, uint32_t aBytesPerPixel)
+{
+ MOZ_ASSERT(aBytesPerPixel == 1 || aBytesPerPixel == 4);
+ return aSize.width * aSize.height * aBytesPerPixel;
+}
+
+/**
+ * Since we want to be able to make eviction decisions based on cost, we need to
+ * be able to look up the CachedSurface which has a certain cost as well as the
+ * cost associated with a certain CachedSurface. To make this possible, in data
+ * structures we actually store a CostEntry, which contains a weak pointer to
+ * its associated surface.
+ *
+ * To make usage of the weak pointer safe, SurfaceCacheImpl always calls
+ * StartTracking after a surface is stored in the cache and StopTracking before
+ * it is removed.
+ */
+class CostEntry
+{
+public:
+ CostEntry(NotNull<CachedSurface*> aSurface, Cost aCost)
+ : mSurface(aSurface)
+ , mCost(aCost)
+ { }
+
+ NotNull<CachedSurface*> Surface() const { return mSurface; }
+ Cost GetCost() const { return mCost; }
+
+ bool operator==(const CostEntry& aOther) const
+ {
+ return mSurface == aOther.mSurface &&
+ mCost == aOther.mCost;
+ }
+
+ bool operator<(const CostEntry& aOther) const
+ {
+ return mCost < aOther.mCost ||
+ (mCost == aOther.mCost && mSurface < aOther.mSurface);
+ }
+
+private:
+ NotNull<CachedSurface*> mSurface;
+ Cost mCost;
+};
+
+/**
+ * A CachedSurface associates a surface with a key that uniquely identifies that
+ * surface.
+ */
+class CachedSurface
+{
+ ~CachedSurface() { }
+public:
+ MOZ_DECLARE_REFCOUNTED_TYPENAME(CachedSurface)
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(CachedSurface)
+
+ explicit CachedSurface(NotNull<ISurfaceProvider*> aProvider)
+ : mProvider(aProvider)
+ , mIsLocked(false)
+ { }
+
+ DrawableSurface GetDrawableSurface() const
+ {
+ if (MOZ_UNLIKELY(IsPlaceholder())) {
+ MOZ_ASSERT_UNREACHABLE("Called GetDrawableSurface() on a placeholder");
+ return DrawableSurface();
+ }
+
+ return mProvider->Surface();
+ }
+
+ void SetLocked(bool aLocked)
+ {
+ if (IsPlaceholder()) {
+ return; // Can't lock a placeholder.
+ }
+
+ // Update both our state and our provider's state. Some surface providers
+ // are permanently locked; maintaining our own locking state enables us to
+ // respect SetLocked() even when it's meaningless from the provider's
+ // perspective.
+ mIsLocked = aLocked;
+ mProvider->SetLocked(aLocked);
+ }
+
+ bool IsLocked() const
+ {
+ return !IsPlaceholder() && mIsLocked && mProvider->IsLocked();
+ }
+
+ bool IsPlaceholder() const { return mProvider->Availability().IsPlaceholder(); }
+ bool IsDecoded() const { return !IsPlaceholder() && mProvider->IsFinished(); }
+
+ ImageKey GetImageKey() const { return mProvider->GetImageKey(); }
+ SurfaceKey GetSurfaceKey() const { return mProvider->GetSurfaceKey(); }
+ nsExpirationState* GetExpirationState() { return &mExpirationState; }
+
+ CostEntry GetCostEntry()
+ {
+ return image::CostEntry(WrapNotNull(this), mProvider->LogicalSizeInBytes());
+ }
+
+ // A helper type used by SurfaceCacheImpl::CollectSizeOfSurfaces.
+ struct MOZ_STACK_CLASS SurfaceMemoryReport
+ {
+ SurfaceMemoryReport(nsTArray<SurfaceMemoryCounter>& aCounters,
+ MallocSizeOf aMallocSizeOf)
+ : mCounters(aCounters)
+ , mMallocSizeOf(aMallocSizeOf)
+ { }
+
+ void Add(NotNull<CachedSurface*> aCachedSurface)
+ {
+ SurfaceMemoryCounter counter(aCachedSurface->GetSurfaceKey(),
+ aCachedSurface->IsLocked());
+
+ if (aCachedSurface->IsPlaceholder()) {
+ return;
+ }
+
+ // Record the memory used by the ISurfaceProvider. This may not have a
+ // straightforward relationship to the size of the surface that
+ // DrawableRef() returns if the surface is generated dynamically. (i.e.,
+ // for surfaces with PlaybackType::eAnimated.)
+ size_t heap = 0;
+ size_t nonHeap = 0;
+ aCachedSurface->mProvider
+ ->AddSizeOfExcludingThis(mMallocSizeOf, heap, nonHeap);
+ counter.Values().SetDecodedHeap(heap);
+ counter.Values().SetDecodedNonHeap(nonHeap);
+
+ mCounters.AppendElement(counter);
+ }
+
+ private:
+ nsTArray<SurfaceMemoryCounter>& mCounters;
+ MallocSizeOf mMallocSizeOf;
+ };
+
+private:
+ nsExpirationState mExpirationState;
+ NotNull<RefPtr<ISurfaceProvider>> mProvider;
+ bool mIsLocked;
+};
+
+static int64_t
+AreaOfIntSize(const IntSize& aSize) {
+ return static_cast<int64_t>(aSize.width) * static_cast<int64_t>(aSize.height);
+}
+
+/**
+ * An ImageSurfaceCache is a per-image surface cache. For correctness we must be
+ * able to remove all surfaces associated with an image when the image is
+ * destroyed or invalidated. Since this will happen frequently, it makes sense
+ * to make it cheap by storing the surfaces for each image separately.
+ *
+ * ImageSurfaceCache also keeps track of whether its associated image is locked
+ * or unlocked.
+ */
+class ImageSurfaceCache
+{
+ ~ImageSurfaceCache() { }
+public:
+ ImageSurfaceCache() : mLocked(false) { }
+
+ MOZ_DECLARE_REFCOUNTED_TYPENAME(ImageSurfaceCache)
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(ImageSurfaceCache)
+
+ typedef
+ nsRefPtrHashtable<nsGenericHashKey<SurfaceKey>, CachedSurface> SurfaceTable;
+
+ bool IsEmpty() const { return mSurfaces.Count() == 0; }
+
+ void Insert(NotNull<CachedSurface*> aSurface)
+ {
+ MOZ_ASSERT(!mLocked || aSurface->IsPlaceholder() || aSurface->IsLocked(),
+ "Inserting an unlocked surface for a locked image");
+ mSurfaces.Put(aSurface->GetSurfaceKey(), aSurface);
+ }
+
+ void Remove(NotNull<CachedSurface*> aSurface)
+ {
+ MOZ_ASSERT(mSurfaces.GetWeak(aSurface->GetSurfaceKey()),
+ "Should not be removing a surface we don't have");
+
+ mSurfaces.Remove(aSurface->GetSurfaceKey());
+ }
+
+ already_AddRefed<CachedSurface> Lookup(const SurfaceKey& aSurfaceKey)
+ {
+ RefPtr<CachedSurface> surface;
+ mSurfaces.Get(aSurfaceKey, getter_AddRefs(surface));
+ return surface.forget();
+ }
+
+ Pair<already_AddRefed<CachedSurface>, MatchType>
+ LookupBestMatch(const SurfaceKey& aIdealKey)
+ {
+ // Try for an exact match first.
+ RefPtr<CachedSurface> exactMatch;
+ mSurfaces.Get(aIdealKey, getter_AddRefs(exactMatch));
+ if (exactMatch && exactMatch->IsDecoded()) {
+ return MakePair(exactMatch.forget(), MatchType::EXACT);
+ }
+
+ // There's no perfect match, so find the best match we can.
+ RefPtr<CachedSurface> bestMatch;
+ for (auto iter = ConstIter(); !iter.Done(); iter.Next()) {
+ NotNull<CachedSurface*> current = WrapNotNull(iter.UserData());
+ const SurfaceKey& currentKey = current->GetSurfaceKey();
+
+ // We never match a placeholder.
+ if (current->IsPlaceholder()) {
+ continue;
+ }
+ // Matching the playback type and SVG context is required.
+ if (currentKey.Playback() != aIdealKey.Playback() ||
+ currentKey.SVGContext() != aIdealKey.SVGContext()) {
+ continue;
+ }
+ // Matching the flags is required.
+ if (currentKey.Flags() != aIdealKey.Flags()) {
+ continue;
+ }
+ // Anything is better than nothing! (Within the constraints we just
+ // checked, of course.)
+ if (!bestMatch) {
+ bestMatch = current;
+ continue;
+ }
+
+ MOZ_ASSERT(bestMatch, "Should have a current best match");
+
+ // Always prefer completely decoded surfaces.
+ bool bestMatchIsDecoded = bestMatch->IsDecoded();
+ if (bestMatchIsDecoded && !current->IsDecoded()) {
+ continue;
+ }
+ if (!bestMatchIsDecoded && current->IsDecoded()) {
+ bestMatch = current;
+ continue;
+ }
+
+ SurfaceKey bestMatchKey = bestMatch->GetSurfaceKey();
+
+ // Compare sizes. We use an area-based heuristic here instead of computing a
+ // truly optimal answer, since it seems very unlikely to make a difference
+ // for realistic sizes.
+ int64_t idealArea = AreaOfIntSize(aIdealKey.Size());
+ int64_t currentArea = AreaOfIntSize(currentKey.Size());
+ int64_t bestMatchArea = AreaOfIntSize(bestMatchKey.Size());
+
+ // If the best match is smaller than the ideal size, prefer bigger sizes.
+ if (bestMatchArea < idealArea) {
+ if (currentArea > bestMatchArea) {
+ bestMatch = current;
+ }
+ continue;
+ }
+ // Other, prefer sizes closer to the ideal size, but still not smaller.
+ if (idealArea <= currentArea && currentArea < bestMatchArea) {
+ bestMatch = current;
+ continue;
+ }
+ // This surface isn't an improvement over the current best match.
+ }
+
+ MatchType matchType;
+ if (bestMatch) {
+ if (!exactMatch) {
+ // No exact match, but we found a substitute.
+ matchType = MatchType::SUBSTITUTE_BECAUSE_NOT_FOUND;
+ } else if (exactMatch != bestMatch) {
+ // The exact match is still decoding, but we found a substitute.
+ matchType = MatchType::SUBSTITUTE_BECAUSE_PENDING;
+ } else {
+ // The exact match is still decoding, but it's the best we've got.
+ matchType = MatchType::EXACT;
+ }
+ } else {
+ if (exactMatch) {
+ // We found an "exact match"; it must have been a placeholder.
+ MOZ_ASSERT(exactMatch->IsPlaceholder());
+ matchType = MatchType::PENDING;
+ } else {
+ // We couldn't find an exact match *or* a substitute.
+ matchType = MatchType::NOT_FOUND;
+ }
+ }
+
+ return MakePair(bestMatch.forget(), matchType);
+ }
+
+ SurfaceTable::Iterator ConstIter() const
+ {
+ return mSurfaces.ConstIter();
+ }
+
+ void SetLocked(bool aLocked) { mLocked = aLocked; }
+ bool IsLocked() const { return mLocked; }
+
+private:
+ SurfaceTable mSurfaces;
+ bool mLocked;
+};
+
+/**
+ * SurfaceCacheImpl is responsible for determining which surfaces will be cached
+ * and managing the surface cache data structures. Rather than interact with
+ * SurfaceCacheImpl directly, client code interacts with SurfaceCache, which
+ * maintains high-level invariants and encapsulates the details of the surface
+ * cache's implementation.
+ */
+class SurfaceCacheImpl final : public nsIMemoryReporter
+{
+public:
+ NS_DECL_ISUPPORTS
+
+ SurfaceCacheImpl(uint32_t aSurfaceCacheExpirationTimeMS,
+ uint32_t aSurfaceCacheDiscardFactor,
+ uint32_t aSurfaceCacheSize)
+ : mExpirationTracker(aSurfaceCacheExpirationTimeMS)
+ , mMemoryPressureObserver(new MemoryPressureObserver)
+ , mDiscardFactor(aSurfaceCacheDiscardFactor)
+ , mMaxCost(aSurfaceCacheSize)
+ , mAvailableCost(aSurfaceCacheSize)
+ , mLockedCost(0)
+ , mOverflowCount(0)
+ {
+ nsCOMPtr<nsIObserverService> os = services::GetObserverService();
+ if (os) {
+ os->AddObserver(mMemoryPressureObserver, "memory-pressure", false);
+ }
+ }
+
+private:
+ virtual ~SurfaceCacheImpl()
+ {
+ nsCOMPtr<nsIObserverService> os = services::GetObserverService();
+ if (os) {
+ os->RemoveObserver(mMemoryPressureObserver, "memory-pressure");
+ }
+
+ UnregisterWeakMemoryReporter(this);
+ }
+
+public:
+ void InitMemoryReporter() { RegisterWeakMemoryReporter(this); }
+
+ InsertOutcome Insert(NotNull<ISurfaceProvider*> aProvider,
+ bool aSetAvailable,
+ const StaticMutexAutoLock& aAutoLock)
+ {
+ // If this is a duplicate surface, refuse to replace the original.
+ // XXX(seth): Calling Lookup() and then RemoveEntry() does the lookup
+ // twice. We'll make this more efficient in bug 1185137.
+ LookupResult result = Lookup(aProvider->GetImageKey(),
+ aProvider->GetSurfaceKey(),
+ aAutoLock,
+ /* aMarkUsed = */ false);
+ if (MOZ_UNLIKELY(result)) {
+ return InsertOutcome::FAILURE_ALREADY_PRESENT;
+ }
+
+ if (result.Type() == MatchType::PENDING) {
+ RemoveEntry(aProvider->GetImageKey(), aProvider->GetSurfaceKey(), aAutoLock);
+ }
+
+ MOZ_ASSERT(result.Type() == MatchType::NOT_FOUND ||
+ result.Type() == MatchType::PENDING,
+ "A LookupResult with no surface should be NOT_FOUND or PENDING");
+
+ // If this is bigger than we can hold after discarding everything we can,
+ // refuse to cache it.
+ Cost cost = aProvider->LogicalSizeInBytes();
+ if (MOZ_UNLIKELY(!CanHoldAfterDiscarding(cost))) {
+ mOverflowCount++;
+ return InsertOutcome::FAILURE;
+ }
+
+ // Remove elements in order of cost until we can fit this in the cache. Note
+ // that locked surfaces aren't in mCosts, so we never remove them here.
+ while (cost > mAvailableCost) {
+ MOZ_ASSERT(!mCosts.IsEmpty(),
+ "Removed everything and it still won't fit");
+ Remove(mCosts.LastElement().Surface(), aAutoLock);
+ }
+
+ // Locate the appropriate per-image cache. If there's not an existing cache
+ // for this image, create it.
+ RefPtr<ImageSurfaceCache> cache = GetImageCache(aProvider->GetImageKey());
+ if (!cache) {
+ cache = new ImageSurfaceCache;
+ mImageCaches.Put(aProvider->GetImageKey(), cache);
+ }
+
+ // If we were asked to mark the cache entry available, do so.
+ if (aSetAvailable) {
+ aProvider->Availability().SetAvailable();
+ }
+
+ NotNull<RefPtr<CachedSurface>> surface =
+ WrapNotNull(new CachedSurface(aProvider));
+
+ // We require that locking succeed if the image is locked and we're not
+ // inserting a placeholder; the caller may need to know this to handle
+ // errors correctly.
+ if (cache->IsLocked() && !surface->IsPlaceholder()) {
+ surface->SetLocked(true);
+ if (!surface->IsLocked()) {
+ return InsertOutcome::FAILURE;
+ }
+ }
+
+ // Insert.
+ MOZ_ASSERT(cost <= mAvailableCost, "Inserting despite too large a cost");
+ cache->Insert(surface);
+ StartTracking(surface, aAutoLock);
+
+ return InsertOutcome::SUCCESS;
+ }
+
+ void Remove(NotNull<CachedSurface*> aSurface,
+ const StaticMutexAutoLock& aAutoLock)
+ {
+ ImageKey imageKey = aSurface->GetImageKey();
+
+ RefPtr<ImageSurfaceCache> cache = GetImageCache(imageKey);
+ MOZ_ASSERT(cache, "Shouldn't try to remove a surface with no image cache");
+
+ // If the surface was not a placeholder, tell its image that we discarded it.
+ if (!aSurface->IsPlaceholder()) {
+ static_cast<Image*>(imageKey)->OnSurfaceDiscarded();
+ }
+
+ StopTracking(aSurface, aAutoLock);
+ cache->Remove(aSurface);
+
+ // Remove the per-image cache if it's unneeded now. (Keep it if the image is
+ // locked, since the per-image cache is where we store that state.)
+ if (cache->IsEmpty() && !cache->IsLocked()) {
+ mImageCaches.Remove(imageKey);
+ }
+ }
+
+ void StartTracking(NotNull<CachedSurface*> aSurface,
+ const StaticMutexAutoLock& aAutoLock)
+ {
+ CostEntry costEntry = aSurface->GetCostEntry();
+ MOZ_ASSERT(costEntry.GetCost() <= mAvailableCost,
+ "Cost too large and the caller didn't catch it");
+
+ mAvailableCost -= costEntry.GetCost();
+
+ if (aSurface->IsLocked()) {
+ mLockedCost += costEntry.GetCost();
+ MOZ_ASSERT(mLockedCost <= mMaxCost, "Locked more than we can hold?");
+ } else {
+ mCosts.InsertElementSorted(costEntry);
+ // This may fail during XPCOM shutdown, so we need to ensure the object is
+ // tracked before calling RemoveObject in StopTracking.
+ mExpirationTracker.AddObjectLocked(aSurface, aAutoLock);
+ }
+ }
+
+ void StopTracking(NotNull<CachedSurface*> aSurface,
+ const StaticMutexAutoLock& aAutoLock)
+ {
+ CostEntry costEntry = aSurface->GetCostEntry();
+
+ if (aSurface->IsLocked()) {
+ MOZ_ASSERT(mLockedCost >= costEntry.GetCost(), "Costs don't balance");
+ mLockedCost -= costEntry.GetCost();
+ // XXX(seth): It'd be nice to use an O(log n) lookup here. This is O(n).
+ MOZ_ASSERT(!mCosts.Contains(costEntry),
+ "Shouldn't have a cost entry for a locked surface");
+ } else {
+ if (MOZ_LIKELY(aSurface->GetExpirationState()->IsTracked())) {
+ mExpirationTracker.RemoveObjectLocked(aSurface, aAutoLock);
+ } else {
+ // Our call to AddObject must have failed in StartTracking; most likely
+ // we're in XPCOM shutdown right now.
+ NS_ASSERTION(ShutdownTracker::ShutdownHasStarted(),
+ "Not expiration-tracking an unlocked surface!");
+ }
+
+ DebugOnly<bool> foundInCosts = mCosts.RemoveElementSorted(costEntry);
+ MOZ_ASSERT(foundInCosts, "Lost track of costs for this surface");
+ }
+
+ mAvailableCost += costEntry.GetCost();
+ MOZ_ASSERT(mAvailableCost <= mMaxCost,
+ "More available cost than we started with");
+ }
+
+ LookupResult Lookup(const ImageKey aImageKey,
+ const SurfaceKey& aSurfaceKey,
+ const StaticMutexAutoLock& aAutoLock,
+ bool aMarkUsed = true)
+ {
+ RefPtr<ImageSurfaceCache> cache = GetImageCache(aImageKey);
+ if (!cache) {
+ // No cached surfaces for this image.
+ return LookupResult(MatchType::NOT_FOUND);
+ }
+
+ RefPtr<CachedSurface> surface = cache->Lookup(aSurfaceKey);
+ if (!surface) {
+ // Lookup in the per-image cache missed.
+ return LookupResult(MatchType::NOT_FOUND);
+ }
+
+ if (surface->IsPlaceholder()) {
+ return LookupResult(MatchType::PENDING);
+ }
+
+ DrawableSurface drawableSurface = surface->GetDrawableSurface();
+ if (!drawableSurface) {
+ // The surface was released by the operating system. Remove the cache
+ // entry as well.
+ Remove(WrapNotNull(surface), aAutoLock);
+ return LookupResult(MatchType::NOT_FOUND);
+ }
+
+ if (aMarkUsed) {
+ MarkUsed(WrapNotNull(surface), WrapNotNull(cache), aAutoLock);
+ }
+
+ MOZ_ASSERT(surface->GetSurfaceKey() == aSurfaceKey,
+ "Lookup() not returning an exact match?");
+ return LookupResult(Move(drawableSurface), MatchType::EXACT);
+ }
+
+ LookupResult LookupBestMatch(const ImageKey aImageKey,
+ const SurfaceKey& aSurfaceKey,
+ const StaticMutexAutoLock& aAutoLock)
+ {
+ RefPtr<ImageSurfaceCache> cache = GetImageCache(aImageKey);
+ if (!cache) {
+ // No cached surfaces for this image.
+ return LookupResult(MatchType::NOT_FOUND);
+ }
+
+ // Repeatedly look up the best match, trying again if the resulting surface
+ // has been freed by the operating system, until we can either lock a
+ // surface for drawing or there are no matching surfaces left.
+ // XXX(seth): This is O(N^2), but N is expected to be very small. If we
+ // encounter a performance problem here we can revisit this.
+
+ RefPtr<CachedSurface> surface;
+ DrawableSurface drawableSurface;
+ MatchType matchType = MatchType::NOT_FOUND;
+ while (true) {
+ Tie(surface, matchType) = cache->LookupBestMatch(aSurfaceKey);
+
+ if (!surface) {
+ return LookupResult(matchType); // Lookup in the per-image cache missed.
+ }
+
+ drawableSurface = surface->GetDrawableSurface();
+ if (drawableSurface) {
+ break;
+ }
+
+ // The surface was released by the operating system. Remove the cache
+ // entry as well.
+ Remove(WrapNotNull(surface), aAutoLock);
+ }
+
+ MOZ_ASSERT_IF(matchType == MatchType::EXACT,
+ surface->GetSurfaceKey() == aSurfaceKey);
+ MOZ_ASSERT_IF(matchType == MatchType::SUBSTITUTE_BECAUSE_NOT_FOUND ||
+ matchType == MatchType::SUBSTITUTE_BECAUSE_PENDING,
+ surface->GetSurfaceKey().SVGContext() == aSurfaceKey.SVGContext() &&
+ surface->GetSurfaceKey().Playback() == aSurfaceKey.Playback() &&
+ surface->GetSurfaceKey().Flags() == aSurfaceKey.Flags());
+
+ if (matchType == MatchType::EXACT) {
+ MarkUsed(WrapNotNull(surface), WrapNotNull(cache), aAutoLock);
+ }
+
+ return LookupResult(Move(drawableSurface), matchType);
+ }
+
+ bool CanHold(const Cost aCost) const
+ {
+ return aCost <= mMaxCost;
+ }
+
+ size_t MaximumCapacity() const
+ {
+ return size_t(mMaxCost);
+ }
+
+ void SurfaceAvailable(NotNull<ISurfaceProvider*> aProvider,
+ const StaticMutexAutoLock& aAutoLock)
+ {
+ if (!aProvider->Availability().IsPlaceholder()) {
+ MOZ_ASSERT_UNREACHABLE("Calling SurfaceAvailable on non-placeholder");
+ return;
+ }
+
+ // Reinsert the provider, requesting that Insert() mark it available. This
+ // may or may not succeed, depending on whether some other decoder has
+ // beaten us to the punch and inserted a non-placeholder version of this
+ // surface first, but it's fine either way.
+ // XXX(seth): This could be implemented more efficiently; we should be able
+ // to just update our data structures without reinserting.
+ Insert(aProvider, /* aSetAvailable = */ true, aAutoLock);
+ }
+
+ void LockImage(const ImageKey aImageKey)
+ {
+ RefPtr<ImageSurfaceCache> cache = GetImageCache(aImageKey);
+ if (!cache) {
+ cache = new ImageSurfaceCache;
+ mImageCaches.Put(aImageKey, cache);
+ }
+
+ cache->SetLocked(true);
+
+ // We don't relock this image's existing surfaces right away; instead, the
+ // image should arrange for Lookup() to touch them if they are still useful.
+ }
+
+ void UnlockImage(const ImageKey aImageKey, const StaticMutexAutoLock& aAutoLock)
+ {
+ RefPtr<ImageSurfaceCache> cache = GetImageCache(aImageKey);
+ if (!cache || !cache->IsLocked()) {
+ return; // Already unlocked.
+ }
+
+ cache->SetLocked(false);
+ DoUnlockSurfaces(WrapNotNull(cache), aAutoLock);
+ }
+
+ void UnlockEntries(const ImageKey aImageKey, const StaticMutexAutoLock& aAutoLock)
+ {
+ RefPtr<ImageSurfaceCache> cache = GetImageCache(aImageKey);
+ if (!cache || !cache->IsLocked()) {
+ return; // Already unlocked.
+ }
+
+ // (Note that we *don't* unlock the per-image cache here; that's the
+ // difference between this and UnlockImage.)
+ DoUnlockSurfaces(WrapNotNull(cache), aAutoLock);
+ }
+
+ void RemoveImage(const ImageKey aImageKey, const StaticMutexAutoLock& aAutoLock)
+ {
+ RefPtr<ImageSurfaceCache> cache = GetImageCache(aImageKey);
+ if (!cache) {
+ return; // No cached surfaces for this image, so nothing to do.
+ }
+
+ // Discard all of the cached surfaces for this image.
+ // XXX(seth): This is O(n^2) since for each item in the cache we are
+ // removing an element from the costs array. Since n is expected to be
+ // small, performance should be good, but if usage patterns change we should
+ // change the data structure used for mCosts.
+ for (auto iter = cache->ConstIter(); !iter.Done(); iter.Next()) {
+ StopTracking(WrapNotNull(iter.UserData()), aAutoLock);
+ }
+
+ // The per-image cache isn't needed anymore, so remove it as well.
+ // This implicitly unlocks the image if it was locked.
+ mImageCaches.Remove(aImageKey);
+ }
+
+ void DiscardAll(const StaticMutexAutoLock& aAutoLock)
+ {
+ // Remove in order of cost because mCosts is an array and the other data
+ // structures are all hash tables. Note that locked surfaces are not
+ // removed, since they aren't present in mCosts.
+ while (!mCosts.IsEmpty()) {
+ Remove(mCosts.LastElement().Surface(), aAutoLock);
+ }
+ }
+
+ void DiscardForMemoryPressure(const StaticMutexAutoLock& aAutoLock)
+ {
+ // Compute our discardable cost. Since locked surfaces aren't discardable,
+ // we exclude them.
+ const Cost discardableCost = (mMaxCost - mAvailableCost) - mLockedCost;
+ MOZ_ASSERT(discardableCost <= mMaxCost, "Discardable cost doesn't add up");
+
+ // Our target is to raise our available cost by (1 / mDiscardFactor) of our
+ // discardable cost - in other words, we want to end up with about
+ // (discardableCost / mDiscardFactor) fewer bytes stored in the surface
+ // cache after we're done.
+ const Cost targetCost = mAvailableCost + (discardableCost / mDiscardFactor);
+
+ if (targetCost > mMaxCost - mLockedCost) {
+ MOZ_ASSERT_UNREACHABLE("Target cost is more than we can discard");
+ DiscardAll(aAutoLock);
+ return;
+ }
+
+ // Discard surfaces until we've reduced our cost to our target cost.
+ while (mAvailableCost < targetCost) {
+ MOZ_ASSERT(!mCosts.IsEmpty(), "Removed everything and still not done");
+ Remove(mCosts.LastElement().Surface(), aAutoLock);
+ }
+ }
+
+ void LockSurface(NotNull<CachedSurface*> aSurface,
+ const StaticMutexAutoLock& aAutoLock)
+ {
+ if (aSurface->IsPlaceholder() || aSurface->IsLocked()) {
+ return;
+ }
+
+ StopTracking(aSurface, aAutoLock);
+
+ // Lock the surface. This can fail.
+ aSurface->SetLocked(true);
+ StartTracking(aSurface, aAutoLock);
+ }
+
+ NS_IMETHOD
+ CollectReports(nsIHandleReportCallback* aHandleReport,
+ nsISupports* aData,
+ bool aAnonymize) override
+ {
+ StaticMutexAutoLock lock(sInstanceMutex);
+
+ // We have explicit memory reporting for the surface cache which is more
+ // accurate than the cost metrics we report here, but these metrics are
+ // still useful to report, since they control the cache's behavior.
+ MOZ_COLLECT_REPORT(
+ "imagelib-surface-cache-estimated-total",
+ KIND_OTHER, UNITS_BYTES, (mMaxCost - mAvailableCost),
+"Estimated total memory used by the imagelib surface cache.");
+
+ MOZ_COLLECT_REPORT(
+ "imagelib-surface-cache-estimated-locked",
+ KIND_OTHER, UNITS_BYTES, mLockedCost,
+"Estimated memory used by locked surfaces in the imagelib surface cache.");
+
+ MOZ_COLLECT_REPORT(
+ "imagelib-surface-cache-overflow-count",
+ KIND_OTHER, UNITS_COUNT, mOverflowCount,
+"Count of how many times the surface cache has hit its capacity and been "
+"unable to insert a new surface.");
+
+ return NS_OK;
+ }
+
+ void CollectSizeOfSurfaces(const ImageKey aImageKey,
+ nsTArray<SurfaceMemoryCounter>& aCounters,
+ MallocSizeOf aMallocSizeOf)
+ {
+ RefPtr<ImageSurfaceCache> cache = GetImageCache(aImageKey);
+ if (!cache) {
+ return; // No surfaces for this image.
+ }
+
+ // Report all surfaces in the per-image cache.
+ CachedSurface::SurfaceMemoryReport report(aCounters, aMallocSizeOf);
+ for (auto iter = cache->ConstIter(); !iter.Done(); iter.Next()) {
+ report.Add(WrapNotNull(iter.UserData()));
+ }
+ }
+
+private:
+ already_AddRefed<ImageSurfaceCache> GetImageCache(const ImageKey aImageKey)
+ {
+ RefPtr<ImageSurfaceCache> imageCache;
+ mImageCaches.Get(aImageKey, getter_AddRefs(imageCache));
+ return imageCache.forget();
+ }
+
+ // This is similar to CanHold() except that it takes into account the costs of
+ // locked surfaces. It's used internally in Insert(), but it's not exposed
+ // publicly because we permit multithreaded access to the surface cache, which
+ // means that the result would be meaningless: another thread could insert a
+ // surface or lock an image at any time.
+ bool CanHoldAfterDiscarding(const Cost aCost) const
+ {
+ return aCost <= mMaxCost - mLockedCost;
+ }
+
+ void MarkUsed(NotNull<CachedSurface*> aSurface,
+ NotNull<ImageSurfaceCache*> aCache,
+ const StaticMutexAutoLock& aAutoLock)
+ {
+ if (aCache->IsLocked()) {
+ LockSurface(aSurface, aAutoLock);
+ } else {
+ mExpirationTracker.MarkUsedLocked(aSurface, aAutoLock);
+ }
+ }
+
+ void DoUnlockSurfaces(NotNull<ImageSurfaceCache*> aCache,
+ const StaticMutexAutoLock& aAutoLock)
+ {
+ // Unlock all the surfaces the per-image cache is holding.
+ for (auto iter = aCache->ConstIter(); !iter.Done(); iter.Next()) {
+ NotNull<CachedSurface*> surface = WrapNotNull(iter.UserData());
+ if (surface->IsPlaceholder() || !surface->IsLocked()) {
+ continue;
+ }
+ StopTracking(surface, aAutoLock);
+ surface->SetLocked(false);
+ StartTracking(surface, aAutoLock);
+ }
+ }
+
+ void RemoveEntry(const ImageKey aImageKey,
+ const SurfaceKey& aSurfaceKey,
+ const StaticMutexAutoLock& aAutoLock)
+ {
+ RefPtr<ImageSurfaceCache> cache = GetImageCache(aImageKey);
+ if (!cache) {
+ return; // No cached surfaces for this image.
+ }
+
+ RefPtr<CachedSurface> surface = cache->Lookup(aSurfaceKey);
+ if (!surface) {
+ return; // Lookup in the per-image cache missed.
+ }
+
+ Remove(WrapNotNull(surface), aAutoLock);
+ }
+
+ struct SurfaceTracker : public ExpirationTrackerImpl<CachedSurface, 2,
+ StaticMutex,
+ StaticMutexAutoLock>
+ {
+ explicit SurfaceTracker(uint32_t aSurfaceCacheExpirationTimeMS)
+ : ExpirationTrackerImpl<CachedSurface, 2,
+ StaticMutex, StaticMutexAutoLock>(
+ aSurfaceCacheExpirationTimeMS, "SurfaceTracker")
+ { }
+
+ protected:
+ void NotifyExpiredLocked(CachedSurface* aSurface,
+ const StaticMutexAutoLock& aAutoLock) override
+ {
+ sInstance->Remove(WrapNotNull(aSurface), aAutoLock);
+ }
+
+ StaticMutex& GetMutex() override
+ {
+ return sInstanceMutex;
+ }
+ };
+
+ struct MemoryPressureObserver : public nsIObserver
+ {
+ NS_DECL_ISUPPORTS
+
+ NS_IMETHOD Observe(nsISupports*,
+ const char* aTopic,
+ const char16_t*) override
+ {
+ StaticMutexAutoLock lock(sInstanceMutex);
+ if (sInstance && strcmp(aTopic, "memory-pressure") == 0) {
+ sInstance->DiscardForMemoryPressure(lock);
+ }
+ return NS_OK;
+ }
+
+ private:
+ virtual ~MemoryPressureObserver() { }
+ };
+
+ nsTArray<CostEntry> mCosts;
+ nsRefPtrHashtable<nsPtrHashKey<Image>,
+ ImageSurfaceCache> mImageCaches;
+ SurfaceTracker mExpirationTracker;
+ RefPtr<MemoryPressureObserver> mMemoryPressureObserver;
+ const uint32_t mDiscardFactor;
+ const Cost mMaxCost;
+ Cost mAvailableCost;
+ Cost mLockedCost;
+ size_t mOverflowCount;
+};
+
+NS_IMPL_ISUPPORTS(SurfaceCacheImpl, nsIMemoryReporter)
+NS_IMPL_ISUPPORTS(SurfaceCacheImpl::MemoryPressureObserver, nsIObserver)
+
+///////////////////////////////////////////////////////////////////////////////
+// Public API
+///////////////////////////////////////////////////////////////////////////////
+
+/* static */ void
+SurfaceCache::Initialize()
+{
+ // Initialize preferences.
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(!sInstance, "Shouldn't initialize more than once");
+
+ // See gfxPrefs for the default values of these preferences.
+
+ // Length of time before an unused surface is removed from the cache, in
+ // milliseconds.
+ uint32_t surfaceCacheExpirationTimeMS =
+ gfxPrefs::ImageMemSurfaceCacheMinExpirationMS();
+
+ // What fraction of the memory used by the surface cache we should discard
+ // when we get a memory pressure notification. This value is interpreted as
+ // 1/N, so 1 means to discard everything, 2 means to discard about half of the
+ // memory we're using, and so forth. We clamp it to avoid division by zero.
+ uint32_t surfaceCacheDiscardFactor =
+ max(gfxPrefs::ImageMemSurfaceCacheDiscardFactor(), 1u);
+
+ // Maximum size of the surface cache, in kilobytes.
+ uint64_t surfaceCacheMaxSizeKB = gfxPrefs::ImageMemSurfaceCacheMaxSizeKB();
+
+ // A knob determining the actual size of the surface cache. Currently the
+ // cache is (size of main memory) / (surface cache size factor) KB
+ // or (surface cache max size) KB, whichever is smaller. The formula
+ // may change in the future, though.
+ // For example, a value of 4 would yield a 256MB cache on a 1GB machine.
+ // The smallest machines we are likely to run this code on have 256MB
+ // of memory, which would yield a 64MB cache on this setting.
+ // We clamp this value to avoid division by zero.
+ uint32_t surfaceCacheSizeFactor =
+ max(gfxPrefs::ImageMemSurfaceCacheSizeFactor(), 1u);
+
+ // Compute the size of the surface cache.
+ uint64_t memorySize = PR_GetPhysicalMemorySize();
+ if (memorySize == 0) {
+ MOZ_ASSERT_UNREACHABLE("PR_GetPhysicalMemorySize not implemented here");
+ memorySize = 256 * 1024 * 1024; // Fall back to 256MB.
+ }
+ uint64_t proposedSize = memorySize / surfaceCacheSizeFactor;
+ uint64_t surfaceCacheSizeBytes = min(proposedSize,
+ surfaceCacheMaxSizeKB * 1024);
+ uint32_t finalSurfaceCacheSizeBytes =
+ min(surfaceCacheSizeBytes, uint64_t(UINT32_MAX));
+
+ // Create the surface cache singleton with the requested settings. Note that
+ // the size is a limit that the cache may not grow beyond, but we do not
+ // actually allocate any storage for surfaces at this time.
+ sInstance = new SurfaceCacheImpl(surfaceCacheExpirationTimeMS,
+ surfaceCacheDiscardFactor,
+ finalSurfaceCacheSizeBytes);
+ sInstance->InitMemoryReporter();
+}
+
+/* static */ void
+SurfaceCache::Shutdown()
+{
+ StaticMutexAutoLock lock(sInstanceMutex);
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(sInstance, "No singleton - was Shutdown() called twice?");
+ sInstance = nullptr;
+}
+
+/* static */ LookupResult
+SurfaceCache::Lookup(const ImageKey aImageKey,
+ const SurfaceKey& aSurfaceKey)
+{
+ StaticMutexAutoLock lock(sInstanceMutex);
+ if (!sInstance) {
+ return LookupResult(MatchType::NOT_FOUND);
+ }
+
+ return sInstance->Lookup(aImageKey, aSurfaceKey, lock);
+}
+
+/* static */ LookupResult
+SurfaceCache::LookupBestMatch(const ImageKey aImageKey,
+ const SurfaceKey& aSurfaceKey)
+{
+ StaticMutexAutoLock lock(sInstanceMutex);
+ if (!sInstance) {
+ return LookupResult(MatchType::NOT_FOUND);
+ }
+
+ return sInstance->LookupBestMatch(aImageKey, aSurfaceKey, lock);
+}
+
+/* static */ InsertOutcome
+SurfaceCache::Insert(NotNull<ISurfaceProvider*> aProvider)
+{
+ StaticMutexAutoLock lock(sInstanceMutex);
+ if (!sInstance) {
+ return InsertOutcome::FAILURE;
+ }
+
+ return sInstance->Insert(aProvider, /* aSetAvailable = */ false, lock);
+}
+
+/* static */ bool
+SurfaceCache::CanHold(const IntSize& aSize, uint32_t aBytesPerPixel /* = 4 */)
+{
+ StaticMutexAutoLock lock(sInstanceMutex);
+ if (!sInstance) {
+ return false;
+ }
+
+ Cost cost = ComputeCost(aSize, aBytesPerPixel);
+ return sInstance->CanHold(cost);
+}
+
+/* static */ bool
+SurfaceCache::CanHold(size_t aSize)
+{
+ StaticMutexAutoLock lock(sInstanceMutex);
+ if (!sInstance) {
+ return false;
+ }
+
+ return sInstance->CanHold(aSize);
+}
+
+/* static */ void
+SurfaceCache::SurfaceAvailable(NotNull<ISurfaceProvider*> aProvider)
+{
+ StaticMutexAutoLock lock(sInstanceMutex);
+ if (!sInstance) {
+ return;
+ }
+
+ sInstance->SurfaceAvailable(aProvider, lock);
+}
+
+/* static */ void
+SurfaceCache::LockImage(const ImageKey aImageKey)
+{
+ StaticMutexAutoLock lock(sInstanceMutex);
+ if (sInstance) {
+ return sInstance->LockImage(aImageKey);
+ }
+}
+
+/* static */ void
+SurfaceCache::UnlockImage(const ImageKey aImageKey)
+{
+ StaticMutexAutoLock lock(sInstanceMutex);
+ if (sInstance) {
+ return sInstance->UnlockImage(aImageKey, lock);
+ }
+}
+
+/* static */ void
+SurfaceCache::UnlockEntries(const ImageKey aImageKey)
+{
+ StaticMutexAutoLock lock(sInstanceMutex);
+ if (sInstance) {
+ return sInstance->UnlockEntries(aImageKey, lock);
+ }
+}
+
+/* static */ void
+SurfaceCache::RemoveImage(const ImageKey aImageKey)
+{
+ StaticMutexAutoLock lock(sInstanceMutex);
+ if (sInstance) {
+ sInstance->RemoveImage(aImageKey, lock);
+ }
+}
+
+/* static */ void
+SurfaceCache::DiscardAll()
+{
+ StaticMutexAutoLock lock(sInstanceMutex);
+ if (sInstance) {
+ sInstance->DiscardAll(lock);
+ }
+}
+
+/* static */ void
+SurfaceCache::CollectSizeOfSurfaces(const ImageKey aImageKey,
+ nsTArray<SurfaceMemoryCounter>& aCounters,
+ MallocSizeOf aMallocSizeOf)
+{
+ StaticMutexAutoLock lock(sInstanceMutex);
+ if (!sInstance) {
+ return;
+ }
+
+ return sInstance->CollectSizeOfSurfaces(aImageKey, aCounters, aMallocSizeOf);
+}
+
+/* static */ size_t
+SurfaceCache::MaximumCapacity()
+{
+ StaticMutexAutoLock lock(sInstanceMutex);
+ if (!sInstance) {
+ return 0;
+ }
+
+ return sInstance->MaximumCapacity();
+}
+
+} // namespace image
+} // namespace mozilla