Restructure flushing relationship between GrContext, GrDrawingManager, and GrResourceCache.
Consolidates all flush actions into GrDrawingManager and makes GrContext::flush a passthrough. Removes the unused and untested discard flush variation. Replaces the indirect overbudget callback mechanism of GrResourceCache with a flag set by resource cache when it wants to flush that is checked after each draw by GrDrawContext. Modifies GrResourceCache::notifyFlushOccurred() to take a param indicating whether it triggered the flush that just occurred. GOLD_TRYBOT_URL= https://gold.skia.org/search?issue=2307053002 Review-Url: https://codereview.chromium.org/2307053002
This commit is contained in:
parent
0a441077dc
commit
1dbb207bab
@ -213,32 +213,11 @@ public:
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// Misc.
|
||||
|
||||
/**
|
||||
* Flags that affect flush() behavior.
|
||||
*/
|
||||
enum FlushBits {
|
||||
/**
|
||||
* A client may reach a point where it has partially rendered a frame
|
||||
* through a GrContext that it knows the user will never see. This flag
|
||||
* causes the flush to skip submission of deferred content to the 3D API
|
||||
* during the flush.
|
||||
*/
|
||||
kDiscard_FlushBit = 0x2,
|
||||
};
|
||||
|
||||
/**
|
||||
* Call to ensure all drawing to the context has been issued to the
|
||||
* underlying 3D API.
|
||||
* @param flagsBitfield flags that control the flushing behavior. See
|
||||
* FlushBits.
|
||||
*/
|
||||
void flush(int flagsBitfield = 0);
|
||||
|
||||
void flushIfNecessary() {
|
||||
if (fFlushToReduceCacheSize || this->caps()->immediateFlush()) {
|
||||
this->flush();
|
||||
}
|
||||
}
|
||||
void flush();
|
||||
|
||||
/**
|
||||
* These flags can be used with the read/write pixels functions below.
|
||||
@ -409,8 +388,6 @@ private:
|
||||
GrBatchFontCache* fBatchFontCache;
|
||||
SkAutoTDelete<GrTextBlobCache> fTextBlobCache;
|
||||
|
||||
// Set by OverbudgetCB() to request that GrContext flush before exiting a draw.
|
||||
bool fFlushToReduceCacheSize;
|
||||
bool fDidTestPMConversions;
|
||||
int fPMToUPMConversion;
|
||||
int fUPMToPMConversion;
|
||||
@ -471,12 +448,6 @@ private:
|
||||
will fail. In such cases fall back to SW conversion. */
|
||||
bool didFailPMUPMConversionTest() const;
|
||||
|
||||
/**
|
||||
* This callback allows the resource cache to callback into the GrContext
|
||||
* when the cache is still over budget after a purge.
|
||||
*/
|
||||
static void OverBudgetCB(void* data);
|
||||
|
||||
/**
|
||||
* A callback similar to the above for use by the TextBlobCache
|
||||
* TODO move textblob draw calls below context so we can use the call above.
|
||||
|
@ -66,7 +66,6 @@ GrContext::GrContext() : fUniqueID(next_id()) {
|
||||
fResourceCache = nullptr;
|
||||
fResourceProvider = nullptr;
|
||||
fBatchFontCache = nullptr;
|
||||
fFlushToReduceCacheSize = false;
|
||||
}
|
||||
|
||||
bool GrContext::init(GrBackend backend, GrBackendContext backendContext,
|
||||
@ -87,7 +86,6 @@ void GrContext::initCommon(const GrContextOptions& options) {
|
||||
|
||||
fCaps = SkRef(fGpu->caps());
|
||||
fResourceCache = new GrResourceCache(fCaps);
|
||||
fResourceCache->setOverBudgetCallback(OverBudgetCB, this);
|
||||
fResourceProvider = new GrResourceProvider(fGpu, fResourceCache, &fSingleOwner);
|
||||
|
||||
fDidTestPMConversions = false;
|
||||
@ -97,7 +95,8 @@ void GrContext::initCommon(const GrContextOptions& options) {
|
||||
dtOptions.fDrawBatchBounds = options.fDrawBatchBounds;
|
||||
dtOptions.fMaxBatchLookback = options.fMaxBatchLookback;
|
||||
dtOptions.fMaxBatchLookahead = options.fMaxBatchLookahead;
|
||||
fDrawingManager.reset(new GrDrawingManager(this, dtOptions, &fSingleOwner));
|
||||
fDrawingManager.reset(new GrDrawingManager(this, dtOptions, options.fImmediateMode,
|
||||
&fSingleOwner));
|
||||
|
||||
// GrBatchFontCache will eventually replace GrFontCache
|
||||
fBatchFontCache = new GrBatchFontCache(this);
|
||||
@ -203,41 +202,21 @@ void GrContext::getResourceCacheUsage(int* resourceCount, size_t* resourceBytes)
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void GrContext::OverBudgetCB(void* data) {
|
||||
SkASSERT(data);
|
||||
|
||||
GrContext* context = reinterpret_cast<GrContext*>(data);
|
||||
|
||||
// Flush the GrBufferedDrawTarget to possibly free up some textures
|
||||
context->fFlushToReduceCacheSize = true;
|
||||
}
|
||||
|
||||
void GrContext::TextBlobCacheOverBudgetCB(void* data) {
|
||||
SkASSERT(data);
|
||||
|
||||
// Unlike the GrResourceCache, TextBlobs are drawn at the SkGpuDevice level, therefore they
|
||||
// cannot use fFlushTorReduceCacheSize because it uses AutoCheckFlush. The solution is to move
|
||||
// drawText calls to below the GrContext level, but this is not trivial because they call
|
||||
// drawPath on SkGpuDevice
|
||||
// TextBlobs are drawn at the SkGpuDevice level, therefore they cannot rely on GrDrawContext
|
||||
// to perform a necessary flush. The solution is to move drawText calls to below the GrContext
|
||||
// level, but this is not trivial because they call drawPath on SkGpuDevice.
|
||||
GrContext* context = reinterpret_cast<GrContext*>(data);
|
||||
context->flush();
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void GrContext::flush(int flagsBitfield) {
|
||||
void GrContext::flush() {
|
||||
ASSERT_SINGLE_OWNER
|
||||
RETURN_IF_ABANDONED
|
||||
bool flushed = false;
|
||||
if (kDiscard_FlushBit & flagsBitfield) {
|
||||
fDrawingManager->reset();
|
||||
} else {
|
||||
flushed = fDrawingManager->flush();
|
||||
}
|
||||
if (flushed) {
|
||||
fResourceCache->notifyFlushOccurred();
|
||||
}
|
||||
fFlushToReduceCacheSize = false;
|
||||
fDrawingManager->flush();
|
||||
}
|
||||
|
||||
bool sw_convert_to_premul(GrPixelConfig srcConfig, int width, int height, size_t inRowBytes,
|
||||
|
@ -59,7 +59,7 @@ public:
|
||||
AutoCheckFlush(GrDrawingManager* drawingManager) : fDrawingManager(drawingManager) {
|
||||
SkASSERT(fDrawingManager);
|
||||
}
|
||||
~AutoCheckFlush() { fDrawingManager->getContext()->flushIfNecessary(); }
|
||||
~AutoCheckFlush() { fDrawingManager->flushIfNecessary(); }
|
||||
|
||||
private:
|
||||
GrDrawingManager* fDrawingManager;
|
||||
|
@ -5,8 +5,10 @@
|
||||
* found in the LICENSE file.
|
||||
*/
|
||||
|
||||
#include "GrDrawContext.h"
|
||||
#include "GrDrawingManager.h"
|
||||
|
||||
#include "GrContext.h"
|
||||
#include "GrDrawContext.h"
|
||||
#include "GrDrawTarget.h"
|
||||
#include "GrPathRenderingDrawContext.h"
|
||||
#include "GrResourceProvider.h"
|
||||
@ -74,9 +76,9 @@ void GrDrawingManager::reset() {
|
||||
fFlushState.reset();
|
||||
}
|
||||
|
||||
bool GrDrawingManager::flush() {
|
||||
void GrDrawingManager::internalFlush(GrResourceCache::FlushType type) {
|
||||
if (fFlushing || this->wasAbandoned()) {
|
||||
return false;
|
||||
return;
|
||||
}
|
||||
fFlushing = true;
|
||||
bool flushed = false;
|
||||
@ -126,8 +128,11 @@ bool GrDrawingManager::flush() {
|
||||
#endif
|
||||
|
||||
fFlushState.reset();
|
||||
// We always have to notify the cache when it requested a flush so it can reset its state.
|
||||
if (flushed || type == GrResourceCache::FlushType::kCacheRequested) {
|
||||
fContext->getResourceCache()->notifyFlushOccurred(type);
|
||||
}
|
||||
fFlushing = false;
|
||||
return flushed;
|
||||
}
|
||||
|
||||
GrDrawTarget* GrDrawingManager::newDrawTarget(GrRenderTarget* rt) {
|
||||
|
@ -13,6 +13,7 @@
|
||||
#include "GrBatchFlushState.h"
|
||||
#include "GrPathRendererChain.h"
|
||||
#include "GrPathRenderer.h"
|
||||
#include "GrResourceCache.h"
|
||||
#include "SkTDArray.h"
|
||||
|
||||
class GrContext;
|
||||
@ -49,11 +50,19 @@ public:
|
||||
GrPathRendererChain::DrawType drawType,
|
||||
GrPathRenderer::StencilSupport* stencilSupport = NULL);
|
||||
|
||||
void flushIfNecessary() {
|
||||
if (fContext->getResourceCache()->requestsFlush()) {
|
||||
this->internalFlush(GrResourceCache::kCacheRequested);
|
||||
} else if (fIsImmediateMode) {
|
||||
this->internalFlush(GrResourceCache::kImmediateMode);
|
||||
}
|
||||
}
|
||||
|
||||
static bool ProgramUnitTest(GrContext* context, int maxStages);
|
||||
|
||||
private:
|
||||
GrDrawingManager(GrContext* context, const GrDrawTarget::Options& optionsForDrawTargets,
|
||||
GrSingleOwner* singleOwner)
|
||||
bool isImmediateMode, GrSingleOwner* singleOwner)
|
||||
: fContext(context)
|
||||
, fOptionsForDrawTargets(optionsForDrawTargets)
|
||||
, fSingleOwner(singleOwner)
|
||||
@ -68,8 +77,8 @@ private:
|
||||
void abandon();
|
||||
void cleanup();
|
||||
void reset();
|
||||
/** Returns true if there was anything to flush and false otherwise */
|
||||
bool flush();
|
||||
void flush() { this->internalFlush(GrResourceCache::FlushType::kExternal); }
|
||||
void internalFlush(GrResourceCache::FlushType);
|
||||
|
||||
friend class GrContext; // for access to: ctor, abandon, reset & flush
|
||||
|
||||
@ -92,6 +101,8 @@ private:
|
||||
|
||||
GrBatchFlushState fFlushState;
|
||||
bool fFlushing;
|
||||
|
||||
bool fIsImmediateMode;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
@ -73,8 +73,6 @@ GrResourceCache::GrResourceCache(const GrCaps* caps)
|
||||
, fBytes(0)
|
||||
, fBudgetedCount(0)
|
||||
, fBudgetedBytes(0)
|
||||
, fOverBudgetCB(nullptr)
|
||||
, fOverBudgetData(nullptr)
|
||||
, fFlushTimestamps(nullptr)
|
||||
, fLastFlushTimestampIndex(0)
|
||||
, fPreferVRAMUseOverFlushes(caps->preferVRAMUseOverFlushes()) {
|
||||
@ -503,10 +501,9 @@ void GrResourceCache::purgeAsNeeded() {
|
||||
this->validate();
|
||||
|
||||
if (stillOverbudget) {
|
||||
// Despite the purge we're still over budget. Call our over budget callback. If this frees
|
||||
// any resources then we'll get notified and take appropriate action.
|
||||
(*fOverBudgetCB)(fOverBudgetData);
|
||||
this->validate();
|
||||
// Set this so that GrDrawingManager will issue a flush to free up resources with pending
|
||||
// IO that we were unable to purge in this pass.
|
||||
fRequestFlush = true;
|
||||
}
|
||||
}
|
||||
|
||||
@ -621,16 +618,26 @@ uint32_t GrResourceCache::getNextTimestamp() {
|
||||
return fTimestamp++;
|
||||
}
|
||||
|
||||
void GrResourceCache::notifyFlushOccurred() {
|
||||
if (fFlushTimestamps) {
|
||||
SkASSERT(SkIsPow2(fMaxUnusedFlushes));
|
||||
fLastFlushTimestampIndex = (fLastFlushTimestampIndex + 1) & (fMaxUnusedFlushes - 1);
|
||||
// get the timestamp before accessing fFlushTimestamps because getNextTimestamp will
|
||||
// reallocate fFlushTimestamps on timestamp overflow.
|
||||
uint32_t timestamp = this->getNextTimestamp();
|
||||
fFlushTimestamps[fLastFlushTimestampIndex] = timestamp;
|
||||
this->purgeAsNeeded();
|
||||
void GrResourceCache::notifyFlushOccurred(FlushType type) {
|
||||
switch (type) {
|
||||
case FlushType::kImmediateMode:
|
||||
break;
|
||||
case FlushType::kCacheRequested:
|
||||
SkASSERT(fRequestFlush);
|
||||
fRequestFlush = false;
|
||||
break;
|
||||
case FlushType::kExternal:
|
||||
if (fFlushTimestamps) {
|
||||
SkASSERT(SkIsPow2(fMaxUnusedFlushes));
|
||||
fLastFlushTimestampIndex = (fLastFlushTimestampIndex + 1) & (fMaxUnusedFlushes - 1);
|
||||
// get the timestamp before accessing fFlushTimestamps because getNextTimestamp will
|
||||
// reallocate fFlushTimestamps on timestamp overflow.
|
||||
uint32_t timestamp = this->getNextTimestamp();
|
||||
fFlushTimestamps[fLastFlushTimestampIndex] = timestamp;
|
||||
}
|
||||
break;
|
||||
}
|
||||
this->purgeAsNeeded();
|
||||
}
|
||||
|
||||
void GrResourceCache::dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const {
|
||||
|
@ -11,6 +11,7 @@
|
||||
#include "GrGpuResource.h"
|
||||
#include "GrGpuResourceCacheAccess.h"
|
||||
#include "GrGpuResourcePriv.h"
|
||||
#include "GrResourceCache.h"
|
||||
#include "GrResourceKey.h"
|
||||
#include "SkMessageBus.h"
|
||||
#include "SkRefCnt.h"
|
||||
@ -163,23 +164,16 @@ public:
|
||||
/** Purges all resources that don't have external owners. */
|
||||
void purgeAllUnlocked();
|
||||
|
||||
/**
|
||||
* The callback function used by the cache when it is still over budget after a purge. The
|
||||
* passed in 'data' is the same 'data' handed to setOverbudgetCallback.
|
||||
*/
|
||||
typedef void (*PFOverBudgetCB)(void* data);
|
||||
/** Returns true if the cache would like a flush to occur in order to make more resources
|
||||
purgeable. */
|
||||
bool requestsFlush() const { return fRequestFlush; }
|
||||
|
||||
/**
|
||||
* Set the callback the cache should use when it is still over budget after a purge. The 'data'
|
||||
* provided here will be passed back to the callback. Note that the cache will attempt to purge
|
||||
* any resources newly freed by the callback.
|
||||
*/
|
||||
void setOverBudgetCallback(PFOverBudgetCB overBudgetCB, void* data) {
|
||||
fOverBudgetCB = overBudgetCB;
|
||||
fOverBudgetData = data;
|
||||
}
|
||||
|
||||
void notifyFlushOccurred();
|
||||
enum FlushType {
|
||||
kExternal,
|
||||
kImmediateMode,
|
||||
kCacheRequested,
|
||||
};
|
||||
void notifyFlushOccurred(FlushType);
|
||||
|
||||
#if GR_CACHE_STATS
|
||||
struct Stats {
|
||||
@ -326,8 +320,7 @@ private:
|
||||
int fBudgetedCount;
|
||||
size_t fBudgetedBytes;
|
||||
|
||||
PFOverBudgetCB fOverBudgetCB;
|
||||
void* fOverBudgetData;
|
||||
bool fRequestFlush;
|
||||
|
||||
// We keep track of the "timestamps" of the last n flushes. If a resource hasn't been used in
|
||||
// that time then we well preemptively purge it to reduce memory usage.
|
||||
|
@ -1008,7 +1008,6 @@ void SkGpuDevice::drawBitmapTile(const SkBitmap& bitmap,
|
||||
if (nullptr == texture) {
|
||||
return;
|
||||
}
|
||||
|
||||
sk_sp<GrColorSpaceXform> colorSpaceXform =
|
||||
GrColorSpaceXform::Make(bitmap.colorSpace(), fDrawContext->getColorSpace());
|
||||
|
||||
|
@ -1133,7 +1133,7 @@ static void test_flush(skiatest::Reporter* reporter) {
|
||||
make_unique_key<1>(&k, i);
|
||||
r->resourcePriv().setUniqueKey(k);
|
||||
r->unref();
|
||||
cache->notifyFlushOccurred();
|
||||
cache->notifyFlushOccurred(GrResourceCache::kExternal);
|
||||
}
|
||||
|
||||
// Send flush notifications to the cache. Each flush should purge the oldest resource.
|
||||
@ -1147,7 +1147,7 @@ static void test_flush(skiatest::Reporter* reporter) {
|
||||
REPORTER_ASSERT(reporter, !SkToBool(r));
|
||||
SkSafeUnref(r);
|
||||
}
|
||||
cache->notifyFlushOccurred();
|
||||
cache->notifyFlushOccurred(GrResourceCache::kExternal);
|
||||
}
|
||||
|
||||
REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
|
||||
@ -1169,13 +1169,13 @@ static void test_flush(skiatest::Reporter* reporter) {
|
||||
} else {
|
||||
r->unref();
|
||||
}
|
||||
cache->notifyFlushOccurred();
|
||||
cache->notifyFlushOccurred(GrResourceCache::kExternal);
|
||||
}
|
||||
|
||||
for (int i = 0; i < kFlushCount; ++i) {
|
||||
// Should get a resource purged every other flush.
|
||||
REPORTER_ASSERT(reporter, kFlushCount - i/2 - 1 == cache->getResourceCount());
|
||||
cache->notifyFlushOccurred();
|
||||
cache->notifyFlushOccurred(GrResourceCache::kExternal);
|
||||
}
|
||||
|
||||
// Unref all the resources that we kept refs on in the first loop.
|
||||
@ -1187,7 +1187,7 @@ static void test_flush(skiatest::Reporter* reporter) {
|
||||
// get kFlushCount additional flushes. Then everything should be purged.
|
||||
for (int i = 0; i < kFlushCount; ++i) {
|
||||
REPORTER_ASSERT(reporter, kFlushCount >> 1 == cache->getResourceCount());
|
||||
cache->notifyFlushOccurred();
|
||||
cache->notifyFlushOccurred(GrResourceCache::kExternal);
|
||||
}
|
||||
REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user