Source code

Revision control

Other Tools

/* -*- 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/. */
#include "gfxGradientCache.h"
#include "MainThreadUtils.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/DataMutex.h"
#include "nsTArray.h"
#include "PLDHashTable.h"
#include "nsExpirationTracker.h"
#include "nsClassHashtable.h"
#include <time.h>
namespace mozilla {
namespace gfx {
using namespace mozilla;
struct GradientCacheKey : public PLDHashEntryHdr {
typedef const GradientCacheKey& KeyType;
typedef const GradientCacheKey* KeyTypePointer;
enum { ALLOW_MEMMOVE = true };
const CopyableTArray<GradientStop> mStops;
ExtendMode mExtend;
BackendType mBackendType;
GradientCacheKey(const nsTArray<GradientStop>& aStops, ExtendMode aExtend,
BackendType aBackendType)
: mStops(aStops), mExtend(aExtend), mBackendType(aBackendType) {}
explicit GradientCacheKey(const GradientCacheKey* aOther)
: mStops(aOther->mStops),
mExtend(aOther->mExtend),
mBackendType(aOther->mBackendType) {}
GradientCacheKey(GradientCacheKey&& aOther) = default;
union FloatUint32 {
float f;
uint32_t u;
};
static PLDHashNumber HashKey(const KeyTypePointer aKey) {
PLDHashNumber hash = 0;
FloatUint32 convert;
hash = AddToHash(hash, int(aKey->mBackendType));
hash = AddToHash(hash, int(aKey->mExtend));
for (uint32_t i = 0; i < aKey->mStops.Length(); i++) {
hash = AddToHash(hash, aKey->mStops[i].color.ToABGR());
// Use the float bits as hash, except for the cases of 0.0 and -0.0 which
// both map to 0
convert.f = aKey->mStops[i].offset;
hash = AddToHash(hash, convert.f ? convert.u : 0);
}
return hash;
}
bool KeyEquals(KeyTypePointer aKey) const {
bool sameStops = true;
if (aKey->mStops.Length() != mStops.Length()) {
sameStops = false;
} else {
for (uint32_t i = 0; i < mStops.Length(); i++) {
if (mStops[i].color.ToABGR() != aKey->mStops[i].color.ToABGR() ||
mStops[i].offset != aKey->mStops[i].offset) {
sameStops = false;
break;
}
}
}
return sameStops && (aKey->mBackendType == mBackendType) &&
(aKey->mExtend == mExtend);
}
static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
};
/**
* This class is what is cached. It need to be allocated in an object separated
* to the cache entry to be able to be tracked by the nsExpirationTracker.
* */
struct GradientCacheData {
GradientCacheData(GradientStops* aStops, GradientCacheKey&& aKey)
: mStops(aStops), mKey(std::move(aKey)) {}
GradientCacheData(GradientCacheData&& aOther) = default;
nsExpirationState* GetExpirationState() { return &mExpirationState; }
nsExpirationState mExpirationState;
const RefPtr<GradientStops> mStops;
GradientCacheKey mKey;
};
/**
* This class implements a cache, that retains the GradientStops used to draw
* the gradients.
*
* An entry stays in the cache as long as it is used often and we don't exceed
* the maximum, in which case the most recently used will be kept.
*/
class GradientCache;
using GradientCacheMutex = StaticDataMutex<UniquePtr<GradientCache>>;
class MOZ_RAII LockedInstance {
public:
explicit LockedInstance(GradientCacheMutex& aDataMutex)
: mAutoLock(aDataMutex.Lock()) {}
UniquePtr<GradientCache>& operator->() const& { return mAutoLock.ref(); }
UniquePtr<GradientCache>& operator->() const&& = delete;
UniquePtr<GradientCache>& operator*() const& { return mAutoLock.ref(); }
UniquePtr<GradientCache>& operator*() const&& = delete;
explicit operator bool() const { return !!mAutoLock.ref(); }
private:
GradientCacheMutex::AutoLock mAutoLock;
};
class GradientCache final
: public ExpirationTrackerImpl<GradientCacheData, 4, GradientCacheMutex,
LockedInstance> {
public:
GradientCache()
: ExpirationTrackerImpl<GradientCacheData, 4, GradientCacheMutex,
LockedInstance>(MAX_GENERATION_MS,
"GradientCache") {}
static bool EnsureInstance() {
LockedInstance lockedInstance(sInstanceMutex);
return EnsureInstanceLocked(lockedInstance);
}
static void DestroyInstance() {
LockedInstance lockedInstance(sInstanceMutex);
if (lockedInstance) {
*lockedInstance = nullptr;
}
}
static void AgeAllGenerations() {
LockedInstance lockedInstance(sInstanceMutex);
if (!lockedInstance) {
return;
}
lockedInstance->AgeAllGenerationsLocked(lockedInstance);
lockedInstance->NotifyHandlerEndLocked(lockedInstance);
}
static GradientCacheData* Lookup(const nsTArray<GradientStop>& aStops,
ExtendMode aExtend,
BackendType aBackendType) {
LockedInstance lockedInstance(sInstanceMutex);
if (!EnsureInstanceLocked(lockedInstance)) {
return nullptr;
}
GradientCacheData* gradientData = lockedInstance->mHashEntries.Get(
GradientCacheKey(aStops, aExtend, aBackendType));
if (!gradientData) {
return nullptr;
}
if (!gradientData->mStops || !gradientData->mStops->IsValid()) {
lockedInstance->NotifyExpiredLocked(gradientData, lockedInstance);
return nullptr;
}
lockedInstance->MarkUsedLocked(gradientData, lockedInstance);
return gradientData;
}
static void RegisterEntry(UniquePtr<GradientCacheData> aValue) {
uint32_t numberOfEntries;
{
LockedInstance lockedInstance(sInstanceMutex);
if (!EnsureInstanceLocked(lockedInstance)) {
return;
}
nsresult rv =
lockedInstance->AddObjectLocked(aValue.get(), lockedInstance);
if (NS_FAILED(rv)) {
// We are OOM, and we cannot track this object. We don't want to store
// entries in the hash table (since the expiration tracker is
// responsible for removing the cache entries), so we avoid putting that
// entry in the table, which is a good thing considering we are short on
// memory anyway, we probably don't want to retain things.
return;
}
lockedInstance->mHashEntries.InsertOrUpdate(aValue->mKey,
std::move(aValue));
numberOfEntries = lockedInstance->mHashEntries.Count();
}
if (numberOfEntries > MAX_ENTRIES) {
// We have too many entries force the cache to age a generation.
NS_DispatchToMainThread(
NS_NewRunnableFunction("GradientCache::OnMaxEntriesBreached", [] {
LockedInstance lockedInstance(sInstanceMutex);
if (!lockedInstance) {
return;
}
lockedInstance->AgeOneGenerationLocked(lockedInstance);
lockedInstance->NotifyHandlerEndLocked(lockedInstance);
}));
}
}
GradientCacheMutex& GetMutex() final { return sInstanceMutex; }
void NotifyExpiredLocked(GradientCacheData* aObject,
const LockedInstance& aLockedInstance) final {
// Remove the gradient from the tracker.
RemoveObjectLocked(aObject, aLockedInstance);
// If entry exists move the data to mRemovedGradientData because we want to
// drop it outside of the lock.
Maybe<UniquePtr<GradientCacheData>> gradientData =
mHashEntries.Extract(aObject->mKey);
if (gradientData.isSome()) {
mRemovedGradientData.AppendElement(std::move(*gradientData));
}
}
void NotifyHandlerEndLocked(const LockedInstance&) final {
NS_DispatchToCurrentThread(
NS_NewRunnableFunction("GradientCache::DestroyRemovedGradientStops",
[stops = std::move(mRemovedGradientData)] {}));
}
private:
static const uint32_t MAX_GENERATION_MS = 10000;
// On Windows some of the Direct2D objects associated with the gradient stops
// can be quite large, so we limit the number of cache entries.
static const uint32_t MAX_ENTRIES = 4000;
static GradientCacheMutex sInstanceMutex;
[[nodiscard]] static bool EnsureInstanceLocked(
LockedInstance& aLockedInstance) {
if (!aLockedInstance) {
// GradientCache must be created on the main thread.
if (!NS_IsMainThread()) {
// This should only happen at shutdown, we fall back to not caching.
return false;
}
*aLockedInstance = MakeUnique<GradientCache>();
}
return true;
}
/**
* FIXME use nsTHashtable to avoid duplicating the GradientCacheKey.
*/
nsClassHashtable<GradientCacheKey, GradientCacheData> mHashEntries;
nsTArray<UniquePtr<GradientCacheData>> mRemovedGradientData;
};
GradientCacheMutex GradientCache::sInstanceMutex("GradientCache");
void gfxGradientCache::Init() {
MOZ_RELEASE_ASSERT(GradientCache::EnsureInstance(),
"First call must be on main thread.");
}
already_AddRefed<GradientStops> gfxGradientCache::GetOrCreateGradientStops(
const DrawTarget* aDT, nsTArray<GradientStop>& aStops, ExtendMode aExtend) {
if (aDT->IsRecording()) {
return aDT->CreateGradientStops(aStops.Elements(), aStops.Length(),
aExtend);
}
GradientCacheData* cached =
GradientCache::Lookup(aStops, aExtend, aDT->GetBackendType());
if (cached) {
return do_AddRef(cached->mStops);
}
RefPtr<GradientStops> gs =
aDT->CreateGradientStops(aStops.Elements(), aStops.Length(), aExtend);
if (!gs) {
return nullptr;
}
GradientCache::RegisterEntry(MakeUnique<GradientCacheData>(
gs, GradientCacheKey(aStops, aExtend, aDT->GetBackendType())));
return gs.forget();
}
void gfxGradientCache::PurgeAllCaches() { GradientCache::AgeAllGenerations(); }
void gfxGradientCache::Shutdown() { GradientCache::DestroyInstance(); }
} // namespace gfx
} // namespace mozilla