2011-07-28 14:26:00 +00:00
|
|
|
/*
|
2014-07-25 14:32:33 +00:00
|
|
|
* Copyright 2014 Google Inc.
|
2011-07-28 14:26:00 +00:00
|
|
|
*
|
|
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
|
|
* found in the LICENSE file.
|
2011-03-30 21:26:44 +00:00
|
|
|
*/
|
|
|
|
|
2014-07-25 15:35:45 +00:00
|
|
|
#ifndef GrGpuResource_DEFINED
|
|
|
|
#define GrGpuResource_DEFINED
|
2011-03-30 21:26:44 +00:00
|
|
|
|
2014-07-25 14:32:33 +00:00
|
|
|
#include "SkInstCnt.h"
|
2012-12-03 14:54:59 +00:00
|
|
|
#include "SkTInternalLList.h"
|
2014-08-28 16:54:34 +00:00
|
|
|
#include "GrResourceKey.h"
|
2012-09-04 13:34:32 +00:00
|
|
|
|
2014-07-25 14:32:33 +00:00
|
|
|
class GrResourceCacheEntry;
|
2014-08-21 20:02:13 +00:00
|
|
|
class GrResourceCache2;
|
2011-03-30 21:26:44 +00:00
|
|
|
class GrGpu;
|
2011-11-15 19:42:07 +00:00
|
|
|
class GrContext;
|
2011-03-30 21:26:44 +00:00
|
|
|
|
2012-04-27 17:24:09 +00:00
|
|
|
/**
|
2014-09-03 21:05:49 +00:00
|
|
|
* Base class for GrGpuResource. Handles the various types of refs we need. Separated out as a base
|
|
|
|
* class to isolate the ref-cnting behavior and provide friendship without exposing all of
|
|
|
|
* GrGpuResource.
|
|
|
|
*
|
|
|
|
* Gpu resources can have three types of refs:
|
|
|
|
* 1) Normal ref (+ by ref(), - by unref()): These are used by code that is issuing draw calls
|
|
|
|
* that read and write the resource via GrDrawTarget and by any object that must own a
|
|
|
|
* GrGpuResource and is itself owned (directly or indirectly) by Skia-client code.
|
|
|
|
* 2) Pending read (+ by addPendingRead(), - by readCompleted()): GrContext has scheduled a read
|
|
|
|
* of the resource by the GPU as a result of a skia API call but hasn't executed it yet.
|
|
|
|
* 3) Pending write (+ by addPendingWrite(), - by writeCompleted()): GrContext has scheduled a
|
|
|
|
* write to the resource by the GPU as a result of a skia API call but hasn't executed it yet.
|
|
|
|
*
|
|
|
|
* The latter two ref types are private and intended only for Gr core code.
|
2012-04-27 17:24:09 +00:00
|
|
|
*/
|
2014-09-03 21:05:49 +00:00
|
|
|
class GrGpuRef : public SkNoncopyable {
|
2011-03-30 21:26:44 +00:00
|
|
|
public:
|
2014-09-03 21:05:49 +00:00
|
|
|
SK_DECLARE_INST_COUNT_ROOT(GrGpuRef)
|
|
|
|
|
|
|
|
virtual ~GrGpuRef();
|
2014-07-25 14:32:33 +00:00
|
|
|
|
2014-09-03 21:05:49 +00:00
|
|
|
// Some of the signatures are written to mirror SkRefCnt so that GrGpuResource can work with
|
|
|
|
// templated helper classes (e.g. SkAutoTUnref). However, we have different categories of
|
|
|
|
// refs (e.g. pending reads). We also don't require thread safety as GrCacheable objects are
|
|
|
|
// not intended to cross thread boundaries.
|
2014-07-25 14:32:33 +00:00
|
|
|
// internal_dispose() exists because of GrTexture's reliance on it. It will be removed
|
|
|
|
// soon.
|
2014-09-03 21:05:49 +00:00
|
|
|
void ref() const {
|
|
|
|
++fRefCnt;
|
|
|
|
// pre-validate once internal_dispose is removed (and therefore 0 ref cnt is not allowed).
|
|
|
|
this->validate();
|
|
|
|
}
|
|
|
|
|
|
|
|
void unref() const {
|
|
|
|
this->validate();
|
|
|
|
--fRefCnt;
|
|
|
|
if (0 == fRefCnt && 0 == fPendingReads && 0 == fPendingWrites) {
|
|
|
|
this->internal_dispose();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-25 14:32:33 +00:00
|
|
|
virtual void internal_dispose() const { SkDELETE(this); }
|
2014-09-03 21:05:49 +00:00
|
|
|
|
|
|
|
/** This is exists to service the old mechanism for recycling scratch textures. It will
|
|
|
|
be removed soon. */
|
|
|
|
bool unique() const { return 1 == (fRefCnt + fPendingReads + fPendingWrites); }
|
|
|
|
|
2014-07-25 14:32:33 +00:00
|
|
|
void validate() const {
|
2014-09-03 21:05:49 +00:00
|
|
|
#ifdef SK_DEBUG
|
|
|
|
SkASSERT(fRefCnt >= 0);
|
|
|
|
SkASSERT(fPendingReads >= 0);
|
|
|
|
SkASSERT(fPendingWrites >= 0);
|
|
|
|
SkASSERT(fRefCnt + fPendingReads + fPendingWrites > 0);
|
2014-07-25 14:32:33 +00:00
|
|
|
#endif
|
2014-09-03 21:05:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
GrGpuRef() : fRefCnt(1), fPendingReads(0), fPendingWrites(0) {}
|
|
|
|
|
|
|
|
private:
|
|
|
|
void addPendingRead() const {
|
|
|
|
this->validate();
|
|
|
|
++fPendingReads;
|
|
|
|
}
|
|
|
|
|
|
|
|
void completedRead() const {
|
|
|
|
this->validate();
|
|
|
|
--fPendingReads;
|
|
|
|
if (0 == fRefCnt && 0 == fPendingReads && 0 == fPendingWrites) {
|
|
|
|
this->internal_dispose();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void addPendingWrite() const {
|
|
|
|
this->validate();
|
|
|
|
++fPendingWrites;
|
|
|
|
}
|
|
|
|
|
|
|
|
void completedWrite() const {
|
|
|
|
this->validate();
|
|
|
|
--fPendingWrites;
|
|
|
|
if (0 == fRefCnt && 0 == fPendingReads && 0 == fPendingWrites) {
|
|
|
|
this->internal_dispose();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
mutable int32_t fRefCnt;
|
|
|
|
mutable int32_t fPendingReads;
|
|
|
|
mutable int32_t fPendingWrites;
|
|
|
|
|
2014-09-04 21:13:44 +00:00
|
|
|
// This class is used to manage conversion of refs to pending reads/writes.
|
2014-09-17 15:05:40 +00:00
|
|
|
friend class GrGpuResourceRef;
|
2014-09-19 18:10:40 +00:00
|
|
|
template <typename T> friend class GrPendingIOResource;
|
2014-09-03 21:05:49 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Base class for objects that can be kept in the GrResourceCache.
|
|
|
|
*/
|
|
|
|
class GrGpuResource : public GrGpuRef {
|
|
|
|
public:
|
|
|
|
SK_DECLARE_INST_COUNT(GrGpuResource)
|
2012-06-05 19:35:09 +00:00
|
|
|
|
2011-03-30 21:26:44 +00:00
|
|
|
/**
|
2014-05-02 21:38:22 +00:00
|
|
|
* Frees the object in the underlying 3D API. It must be safe to call this
|
|
|
|
* when the object has been previously abandoned.
|
2011-03-30 21:26:44 +00:00
|
|
|
*/
|
|
|
|
void release();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Removes references to objects in the underlying 3D API without freeing
|
|
|
|
* them. Used when the API context has been torn down before the GrContext.
|
|
|
|
*/
|
|
|
|
void abandon();
|
|
|
|
|
|
|
|
/**
|
2014-05-02 21:38:22 +00:00
|
|
|
* Tests whether a object has been abandoned or released. All objects will
|
|
|
|
* be in this state after their creating GrContext is destroyed or has
|
|
|
|
* contextLost called. It's up to the client to test wasDestroyed() before
|
|
|
|
* attempting to use an object if it holds refs on objects across
|
2011-03-30 21:26:44 +00:00
|
|
|
* ~GrContext, freeResources with the force flag, or contextLost.
|
|
|
|
*
|
2014-05-02 21:38:22 +00:00
|
|
|
* @return true if the object has been released or abandoned,
|
2011-03-30 21:26:44 +00:00
|
|
|
* false otherwise.
|
|
|
|
*/
|
2014-05-02 21:38:22 +00:00
|
|
|
bool wasDestroyed() const { return NULL == fGpu; }
|
2011-03-30 21:26:44 +00:00
|
|
|
|
2011-07-26 12:32:36 +00:00
|
|
|
/**
|
2014-05-02 21:38:22 +00:00
|
|
|
* Retrieves the context that owns the object. Note that it is possible for
|
|
|
|
* this to return NULL. When objects have been release()ed or abandon()ed
|
|
|
|
* they no longer have an owning context. Destroying a GrContext
|
|
|
|
* automatically releases all its resources.
|
2013-01-23 21:37:01 +00:00
|
|
|
*/
|
2012-08-16 14:49:16 +00:00
|
|
|
const GrContext* getContext() const;
|
|
|
|
GrContext* getContext();
|
|
|
|
|
2014-07-25 14:32:33 +00:00
|
|
|
/**
|
|
|
|
* Retrieves the amount of GPU memory used by this resource in bytes. It is
|
|
|
|
* approximate since we aren't aware of additional padding or copies made
|
|
|
|
* by the driver.
|
|
|
|
*
|
|
|
|
* @return the amount of GPU memory used in bytes
|
|
|
|
*/
|
|
|
|
virtual size_t gpuMemorySize() const = 0;
|
|
|
|
|
|
|
|
void setCacheEntry(GrResourceCacheEntry* cacheEntry) { fCacheEntry = cacheEntry; }
|
|
|
|
GrResourceCacheEntry* getCacheEntry() { return fCacheEntry; }
|
2014-05-02 21:38:22 +00:00
|
|
|
|
2014-08-28 16:54:34 +00:00
|
|
|
/**
|
|
|
|
* If this resource can be used as a scratch resource this returns a valid
|
|
|
|
* scratch key. Otherwise it returns a key for which isNullScratch is true.
|
|
|
|
*/
|
|
|
|
const GrResourceKey& getScratchKey() const { return fScratchKey; }
|
|
|
|
|
2013-01-23 20:25:22 +00:00
|
|
|
/**
|
2014-09-05 19:23:12 +00:00
|
|
|
* Gets an id that is unique for this GrGpuResource object. It is static in that it does
|
|
|
|
* not change when the content of the GrGpuResource object changes. This will never return
|
2014-07-25 14:32:33 +00:00
|
|
|
* 0.
|
2013-01-23 20:25:22 +00:00
|
|
|
*/
|
2014-07-25 14:32:33 +00:00
|
|
|
uint32_t getUniqueID() const { return fUniqueID; }
|
|
|
|
|
|
|
|
protected:
|
2014-08-26 21:01:07 +00:00
|
|
|
// This must be called by every GrGpuObject. It should be called once the object is fully
|
|
|
|
// initialized (i.e. not in a base class constructor).
|
|
|
|
void registerWithCache();
|
|
|
|
|
2014-07-25 15:35:45 +00:00
|
|
|
GrGpuResource(GrGpu*, bool isWrapped);
|
|
|
|
virtual ~GrGpuResource();
|
2012-04-27 17:24:09 +00:00
|
|
|
|
2014-09-05 20:34:00 +00:00
|
|
|
bool isInCache() const { return SkToBool(fCacheEntry); }
|
2014-07-25 14:32:33 +00:00
|
|
|
|
2012-04-27 17:24:09 +00:00
|
|
|
GrGpu* getGpu() const { return fGpu; }
|
2011-03-30 21:26:44 +00:00
|
|
|
|
2012-09-05 18:37:39 +00:00
|
|
|
// Derived classes should always call their parent class' onRelease
|
|
|
|
// and onAbandon methods in their overrides.
|
|
|
|
virtual void onRelease() {};
|
|
|
|
virtual void onAbandon() {};
|
2011-03-30 21:26:44 +00:00
|
|
|
|
2013-10-29 14:06:15 +00:00
|
|
|
bool isWrapped() const { return kWrapped_FlagBit & fFlags; }
|
2012-08-28 12:34:17 +00:00
|
|
|
|
2014-07-25 14:32:33 +00:00
|
|
|
/**
|
|
|
|
* This entry point should be called whenever gpuMemorySize() begins
|
|
|
|
* reporting a different size. If the object is in the cache, it will call
|
|
|
|
* gpuMemorySize() immediately and pass the new size on to the resource
|
|
|
|
* cache.
|
|
|
|
*/
|
|
|
|
void didChangeGpuMemorySize() const;
|
|
|
|
|
2014-08-28 16:54:34 +00:00
|
|
|
/**
|
|
|
|
* Optionally called by the GrGpuResource subclass if the resource can be used as scratch.
|
|
|
|
* By default resources are not usable as scratch. This should only be called once.
|
|
|
|
**/
|
|
|
|
void setScratchKey(const GrResourceKey& scratchKey);
|
|
|
|
|
2011-03-30 21:26:44 +00:00
|
|
|
private:
|
2013-08-28 14:17:03 +00:00
|
|
|
#ifdef SK_DEBUG
|
2012-09-04 13:34:32 +00:00
|
|
|
friend class GrGpu; // for assert in GrGpu to access getGpu
|
|
|
|
#endif
|
2011-03-30 21:26:44 +00:00
|
|
|
|
2014-07-25 14:32:33 +00:00
|
|
|
static uint32_t CreateUniqueID();
|
|
|
|
|
2014-08-21 20:02:13 +00:00
|
|
|
// We're in an internal doubly linked list owned by GrResourceCache2
|
2014-07-25 15:35:45 +00:00
|
|
|
SK_DECLARE_INTERNAL_LLIST_INTERFACE(GrGpuResource);
|
2011-03-30 21:26:44 +00:00
|
|
|
|
2014-08-21 20:02:13 +00:00
|
|
|
// This is not ref'ed but abandon() or release() will be called before the GrGpu object
|
|
|
|
// is destroyed. Those calls set will this to NULL.
|
|
|
|
GrGpu* fGpu;
|
|
|
|
|
2013-01-23 20:25:22 +00:00
|
|
|
enum Flags {
|
2013-10-29 14:06:15 +00:00
|
|
|
/**
|
2014-05-02 21:38:22 +00:00
|
|
|
* This object wraps a GPU object given to us by the user.
|
2013-10-30 07:01:56 +00:00
|
|
|
* Lifetime management is left up to the user (i.e., we will not
|
2013-10-29 14:06:15 +00:00
|
|
|
* free it).
|
|
|
|
*/
|
|
|
|
kWrapped_FlagBit = 0x1,
|
2013-01-23 20:25:22 +00:00
|
|
|
};
|
|
|
|
|
2014-07-25 14:32:33 +00:00
|
|
|
uint32_t fFlags;
|
|
|
|
|
|
|
|
GrResourceCacheEntry* fCacheEntry; // NULL if not in cache
|
|
|
|
const uint32_t fUniqueID;
|
|
|
|
|
2014-08-28 16:54:34 +00:00
|
|
|
GrResourceKey fScratchKey;
|
|
|
|
|
2014-09-03 21:05:49 +00:00
|
|
|
typedef GrGpuRef INHERITED;
|
2011-03-30 21:26:44 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#endif
|