Create debug only SkSingleOwner

src/gpu/GrContext.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrContext.h"
 #include "GrContextOptions.h"
 #include "GrDrawingManager.h"
 #include "GrDrawContext.h"
 #include "GrLayerCache.h"
 #include "GrResourceCache.h"
 #include "GrResourceProvider.h"
 #include "GrSoftwarePathRenderer.h"
 #include "GrSurfacePriv.h"
 
 #include "SkConfig8888.h"
 #include "SkGrPriv.h"
 
 #include "effects/GrConfigConversionEffect.h"
 #include "text/GrTextBlobCache.h"
 
 #define ASSERT_OWNED_RESOURCE(R) SkASSERT(!(R) || (R)->getContext() == this)
-#define RETURN_IF_ABANDONED if (fDrawingManager->abandoned()) { return; }
-#define RETURN_FALSE_IF_ABANDONED if (fDrawingManager->abandoned()) { return false; }
-#define RETURN_NULL_IF_ABANDONED if (fDrawingManager->abandoned()) { return nullptr; }
+#define TAKE_DEBUG_MUTEX \
+    SkASSERT(1 == fSafetyMutex.fSemaphore.fCount || fSafetyMutex.fOwner == SkGetThreadID()); \
+    SkDEBUGCODE(SkAutoTAcquire<SkRecursiveMutex> debug_SafetyMutex(fSafetyMutex);)
+#define RETURN_IF_ABANDONED TAKE_DEBUG_MUTEX if (fDrawingManager->abandoned()) { return; }
+#define RETURN_FALSE_IF_ABANDONED \
+    TAKE_DEBUG_MUTEX \
+    if (fDrawingManager->abandoned()) { return false; }
+#define RETURN_NULL_IF_ABANDONED \
+    TAKE_DEBUG_MUTEX \
+    if (fDrawingManager->abandoned()) { return nullptr; }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 GrContext* GrContext::Create(GrBackend backend, GrBackendContext backendContext) {
     GrContextOptions defaultOptions;
     return Create(backend, backendContext, defaultOptions);
 }
 
 GrContext* GrContext::Create(GrBackend backend, GrBackendContext backendContext,
                              const GrContextOptions& options) {
@@ skipping 31 matching lines @@
 
     fGpu = GrGpu::Create(backend, backendContext, options, this);
     if (!fGpu) {
         return false;
     }
     this->initCommon(options);
     return true;
 }
 
 void GrContext::initCommon(const GrContextOptions& options) {
+    TAKE_DEBUG_MUTEX

[mtklein, 2016/01/05 22:47:50]

What is the constraint that you are trying to enforce?

It looks like both Create() methods call initCommon().  Does every GrContext hit
this line before it exits Create()?

So is the constraint, a GrContext must only be used on the thread that creates
it?

[joshualitt, 2016/01/06 14:03:27]

No, but a GrContext may only ever be used from one thread at a time.  That
single thread may arbitrarily re-enter the GrContext.

[mtklein, 2016/01/06 14:33:46]

So what do we need the reentrant mutex for?  We're not also trying to queue
other threads up for access to the GrContext, are we?

Can't you just do something ordinary?

class SingleOwner {
public:
    SingleOwner() : fOwner(kIllegalThreadID), fReentranceCount(0) {}

    struct AutoEnforce {
        AutoEnforce(SingleOwner* so) : fSO(so) { fSO->enter(); }
        ~AutoEnforce() { fSO->exit(); }

        SingleOwner* fSO;
    };

private:
    void enter() {
        SkAutoMutexAcquire lock(fMutex);
        SkThreadID self = SkGetThreadID();
        SkASSERT(fOwner == self || fOwner == kIllegalThreadID);
        fReentranceCount++;
        fOwner = self;
    }

    void exit() {
        SkAutoMutexAcquire lock(fMutex);
        fReentranceCount--;
        if (fReentranceCount == 0) {
            fOwner = kIllegalThreadID;
        }
    }

    SkMutex fMutex;
    SkThreadID fOwner;    // guarded by fMutex
    int fReentranceCount; // guarded by fMutex
};

+
     fCaps = SkRef(fGpu->caps());
     fResourceCache = new GrResourceCache(fCaps);
     fResourceCache->setOverBudgetCallback(OverBudgetCB, this);
     fResourceProvider = new GrResourceProvider(fGpu, fResourceCache);
 
     fLayerCache.reset(new GrLayerCache(this));
 
     fDidTestPMConversions = false;
 
     GrDrawTarget::Options dtOptions;
     dtOptions.fClipBatchToBounds = options.fClipBatchToBounds;
     dtOptions.fDrawBatchBounds = options.fDrawBatchBounds;
     dtOptions.fMaxBatchLookback = options.fMaxBatchLookback;
     fDrawingManager.reset(new GrDrawingManager(this, dtOptions));
 
     // GrBatchFontCache will eventually replace GrFontCache
     fBatchFontCache = new GrBatchFontCache(this);
 
     fTextBlobCache.reset(new GrTextBlobCache(TextBlobCacheOverBudgetCB, this));
 }
 
 GrContext::~GrContext() {
+    TAKE_DEBUG_MUTEX
+
     if (!fGpu) {
         SkASSERT(!fCaps);
         return;
     }
 
     this->flush();
 
     fDrawingManager->cleanup();
 
     for (int i = 0; i < fCleanUpData.count(); ++i) {
         (*fCleanUpData[i].fFunc)(this, fCleanUpData[i].fInfo);
     }
 
     delete fResourceProvider;
     delete fResourceCache;
     delete fBatchFontCache;
 
     fGpu->unref();
     fCaps->unref();
 }
 
 void GrContext::abandonContext() {
+    TAKE_DEBUG_MUTEX
+
     fResourceProvider->abandon();
 
     // Need to abandon the drawing manager first so all the render targets
     // will be released/forgotten before they too are abandoned.
     fDrawingManager->abandon();
 
     // abandon first to so destructors
     // don't try to free the resources in the API.
     fResourceCache->abandonAll();
 
     fGpu->contextAbandoned();
 
     fBatchFontCache->freeAll();
     fLayerCache->freeAll();
     fTextBlobCache->freeAll();
 }
 
 void GrContext::resetContext(uint32_t state) {
+    TAKE_DEBUG_MUTEX
+
     fGpu->markContextDirty(state);
 }
 
 void GrContext::freeGpuResources() {
+    TAKE_DEBUG_MUTEX
+
     this->flush();
 
     fBatchFontCache->freeAll();
     fLayerCache->freeAll();
 
     fDrawingManager->freeGpuResources();
 
     fResourceCache->purgeAllUnlocked();
 }
 
 void GrContext::getResourceCacheUsage(int* resourceCount, size_t* resourceBytes) const {
+    TAKE_DEBUG_MUTEX
+
     if (resourceCount) {
         *resourceCount = fResourceCache->getBudgetedResourceCount();
     }
     if (resourceBytes) {
         *resourceBytes = fResourceCache->getBudgetedResourceBytes();
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ skipping 12 matching lines @@
     // 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
     GrContext* context = reinterpret_cast<GrContext*>(data);
     context->flush();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrContext::flush(int flagsBitfield) {

[mtklein, 2016/01/05 22:47:50]

Why do some methods TAKE_DEBUG_MUTEX and not others?

[mtklein, 2016/01/05 22:55:45]

Oh, I see.  That's very confusing.

[joshualitt, 2016/01/06 14:03:27]

I can explicitly break it out of the macro if that makes it easier to follow

[mtklein, 2016/01/06 14:33:46]

I think it would.

     RETURN_IF_ABANDONED
 
     if (kDiscard_FlushBit & flagsBitfield) {
         fDrawingManager->reset();
     } else {
         fDrawingManager->flush();
     }
     fResourceCache->notifyFlushOccurred();
     fFlushToReduceCacheSize = false;
 }
@@ skipping 328 matching lines @@
 void GrContext::flushSurfaceWrites(GrSurface* surface) {
     RETURN_IF_ABANDONED
     if (surface->surfacePriv().hasPendingWrite()) {
         this->flush();
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 int GrContext::getRecommendedSampleCount(GrPixelConfig config,
                                          SkScalar dpi) const {
+    TAKE_DEBUG_MUTEX
+
     if (!this->caps()->isConfigRenderable(config, true)) {
         return 0;
     }
     int chosenSampleCount = 0;
     if (fGpu->caps()->shaderCaps()->pathRenderingSupport()) {
         if (dpi >= 250.0f) {
             chosenSampleCount = 4;
         } else {
             chosenSampleCount = 16;
         }
     }
     return chosenSampleCount <= fGpu->caps()->maxSampleCount() ?
         chosenSampleCount : 0;
 }
 
 
 GrDrawContext* GrContext::drawContext(GrRenderTarget* rt, const SkSurfaceProps* surfaceProps) {
+    TAKE_DEBUG_MUTEX
     return fDrawingManager->drawContext(rt, surfaceProps);
 }
 
-bool GrContext::abandoned() const { 
+bool GrContext::abandoned() const {
+    TAKE_DEBUG_MUTEX
     return fDrawingManager->abandoned();
 }
 
 namespace {
 void test_pm_conversions(GrContext* ctx, int* pmToUPMValue, int* upmToPMValue) {
     GrConfigConversionEffect::PMConversion pmToUPM;
     GrConfigConversionEffect::PMConversion upmToPM;
     GrConfigConversionEffect::TestForPreservingPMConversions(ctx, &pmToUPM, &upmToPM);
     *pmToUPMValue = pmToUPM;
     *upmToPMValue = upmToPM;
 }
 }
 
 void GrContext::testPMConversionsIfNecessary(uint32_t flags) {
+    TAKE_DEBUG_MUTEX
     if (SkToBool(kUnpremul_PixelOpsFlag & flags)) {
         SkAutoMutexAcquire ama(fTestPMConversionsMutex);
         if (!fDidTestPMConversions) {
             test_pm_conversions(this, &fPMToUPMConversion, &fUPMToPMConversion);
             fDidTestPMConversions = true;
         }
     }
 }
 
 const GrFragmentProcessor* GrContext::createPMToUPMEffect(GrTexture* texture,
                                                           bool swapRAndB,
                                                           const SkMatrix& matrix) const {
+    TAKE_DEBUG_MUTEX
     // We should have already called this->testPMConversionsIfNecessary().
     SkASSERT(fDidTestPMConversions);
     GrConfigConversionEffect::PMConversion pmToUPM =
         static_cast<GrConfigConversionEffect::PMConversion>(fPMToUPMConversion);
     if (GrConfigConversionEffect::kNone_PMConversion != pmToUPM) {
         return GrConfigConversionEffect::Create(texture, swapRAndB, pmToUPM, matrix);
     } else {
         return nullptr;
     }
 }
 
 const GrFragmentProcessor* GrContext::createUPMToPMEffect(GrTexture* texture,
                                                           bool swapRAndB,
                                                           const SkMatrix& matrix) const {
+    TAKE_DEBUG_MUTEX
     // We should have already called this->testPMConversionsIfNecessary().
     SkASSERT(fDidTestPMConversions);
     GrConfigConversionEffect::PMConversion upmToPM =
         static_cast<GrConfigConversionEffect::PMConversion>(fUPMToPMConversion);
     if (GrConfigConversionEffect::kNone_PMConversion != upmToPM) {
         return GrConfigConversionEffect::Create(texture, swapRAndB, upmToPM, matrix);
     } else {
         return nullptr;
     }
 }
 
 bool GrContext::didFailPMUPMConversionTest() const {
+    TAKE_DEBUG_MUTEX
     // We should have already called this->testPMConversionsIfNecessary().
     SkASSERT(fDidTestPMConversions);
     // The PM<->UPM tests fail or succeed together so we only need to check one.
     return GrConfigConversionEffect::kNone_PMConversion == fPMToUPMConversion;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 void GrContext::getResourceCacheLimits(int* maxTextures, size_t* maxTextureBytes) const {
+    TAKE_DEBUG_MUTEX
     if (maxTextures) {
         *maxTextures = fResourceCache->getMaxResourceCount();
     }
     if (maxTextureBytes) {
         *maxTextureBytes = fResourceCache->getMaxResourceBytes();
     }
 }
 
 void GrContext::setResourceCacheLimits(int maxTextures, size_t maxTextureBytes) {
+    TAKE_DEBUG_MUTEX
     fResourceCache->setLimits(maxTextures, maxTextureBytes);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 void GrContext::dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const {
+    TAKE_DEBUG_MUTEX
     fResourceCache->dumpMemoryStatistics(traceMemoryDump);
 }