Add specialized content key class for resources.

include/gpu/GrResourceKey.h

 
 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrResourceKey_DEFINED
 #define GrResourceKey_DEFINED
 
 #include "GrTypes.h"
 #include "SkTemplates.h"
 #include "GrBinHashKey.h"
 
+uint32_t GrResourceKeyHash(const uint32_t* data, size_t size);
+
+class GrResourceKey {

[bsalomon, 2015/01/21 19:54:58]

The diff sucks... this is basically the old GrScratchKey made subclassable for
new subclasses GrScratchKey and GrResourceKey.

I changed size() to have an impl that doesn't validate() because sometimes we
need the size without validating (e.g. to avoid recursion within validate()).

The builder is also subclassed in the two subclasses of GrResourceKey.

+public:
+    uint32_t hash() const {
+        this->validate();
+        return fKey[kHash_MetaDataIdx];
+    }
+
+    size_t size() const {
+        this->validate();
+        return this->internalSize();
+    }
+
+    const uint32_t* data() const {
+        this->validate();
+        return &fKey[kMetaDataCnt];
+    }
+
+protected:
+    static const uint32_t kInvalidDomain = 0;
+
+    GrResourceKey() { this->reset(); }
+
+    /** Reset to an invalid key. */
+    void reset() {
+        GR_STATIC_ASSERT((uint16_t)kInvalidDomain == kInvalidDomain);
+        fKey.reset(kMetaDataCnt);
+        fKey[kHash_MetaDataIdx] = 0;
+        fKey[kDomainAndSize_MetaDataIdx] = kInvalidDomain;
+    }
+
+    bool operator==(const GrResourceKey& that) const {
+        return 0 == memcmp(fKey.get(), that.fKey.get(), this->size());
+    }
+
+    GrResourceKey& operator=(const GrResourceKey& that) {
+        size_t bytes = that.size();
+        fKey.reset(SkToInt(bytes / sizeof(uint32_t)));

[robertphillips, 2015/01/22 16:49:12]

// bytes is guaranteed to be a multiple of 4 ?

[bsalomon, 2015/01/22 19:23:17]

Added an assert to that effect.

+        memcpy(fKey.get(), that.fKey.get(), bytes);
+        return *this;
+    }
+
+    bool isValid() const { return kInvalidDomain != this->domain(); }
+
+    uint32_t domain() const { return fKey[kDomainAndSize_MetaDataIdx] & 0xffff; }
+
+    /** Used to initialize a key. */
+    class Builder {
+    public:
+        Builder(GrResourceKey* key, uint32_t domain, int data32Count) : fKey(key) {
+            SkASSERT(data32Count >= 0);
+            SkASSERT(domain != kInvalidDomain);
+            key->fKey.reset(kMetaDataCnt + data32Count);
+            int size = (data32Count + kMetaDataCnt) * sizeof(uint32_t);
+            SkASSERT(SkToU16(size) == size);
+            SkASSERT(SkToU16(domain) == domain);
+            key->fKey[kDomainAndSize_MetaDataIdx] = domain | (size << 16);
+        }
+
+        ~Builder() { this->finish(); }
+
+        void finish() {
+            if (NULL == fKey) {
+                return;
+            }
+            GR_STATIC_ASSERT(0 == kHash_MetaDataIdx);
+            uint32_t* hash = &fKey->fKey[kHash_MetaDataIdx];
+            *hash = GrResourceKeyHash(hash + 1, fKey->internalSize() - sizeof(uint32_t));
+            fKey->validate();
+            fKey = NULL;
+        }
+
+        uint32_t& operator[](int dataIdx) {
+            SkASSERT(fKey);
+            SkDEBUGCODE(size_t dataCount = fKey->internalSize() / sizeof(uint32_t) - kMetaDataCnt;)
+            SkASSERT(SkToU32(dataIdx) < dataCount);
+            return fKey->fKey[kMetaDataCnt + dataIdx];
+        }
+
+    private:
+        GrResourceKey* fKey;
+    };
+
+private:
+    size_t internalSize() const {
+        return fKey[kDomainAndSize_MetaDataIdx] >> 16;
+    }
+
+    void validate() const {
+        SkASSERT(fKey[kHash_MetaDataIdx] ==
+                 GrResourceKeyHash(&fKey[kHash_MetaDataIdx] + 1,
+                                   this->internalSize() - sizeof(uint32_t)));
+    }
+
+    enum MetaDataIdx {
+        kHash_MetaDataIdx,
+        // The key domain and size are packed into a single uint32_t.
+        kDomainAndSize_MetaDataIdx,
+
+        kLastMetaDataIdx = kDomainAndSize_MetaDataIdx
+    };
+    static const uint32_t kMetaDataCnt = kLastMetaDataIdx + 1;
+
+    friend class TestResource; // For unit test to access kMetaDataCnt.
+
+    // bmp textures require 4 uint32_t values.
+    SkAutoSTArray<kMetaDataCnt + 4, uint32_t> fKey;
+};
+
 /**
  * A key used for scratch resources. The key consists of a resource type (subclass) identifier, a
  * hash, a data length, and type-specific data. A Builder object is used to initialize the
  * key contents. The contents must be initialized before the key can be used.
  */
-class GrScratchKey {
+class GrScratchKey : public GrResourceKey {

[robertphillips, 2015/01/22 16:49:12]

Shouldn't this be last ?

[bsalomon, 2015/01/22 19:23:17]

it breaks using it in the builder to put it last

+private:
+    typedef GrResourceKey INHERITED;
+
 public:

[robertphillips, 2015/01/22 16:49:12]

Does this need to be public ?

[bsalomon, 2015/01/22 19:23:17]

Removed it

+    static const uint32_t kInvalidResourceType = INHERITED::kInvalidDomain;
+
     /** Uniquely identifies the type of resource that is cached as scratch. */
     typedef uint32_t ResourceType;
     /** Generate a unique ResourceType. */
     static ResourceType GenerateResourceType();
 
-    GrScratchKey() { this->reset(); }
+    /** Creates an invalid scratch key. It must be initialized using a Builder object before use. */
+    GrScratchKey() {}
+
     GrScratchKey(const GrScratchKey& that) { *this = that; }
 
-    /** Reset to an invalid key. */
-    void reset() {
-        fKey.reset(kMetaDataCnt);
-        fKey[kHash_MetaDataIdx] = 0;
-        fKey[kTypeAndSize_MetaDataIdx] = kInvalidResourceType;
-    }
+    /** reset() returns the key to the invalid state. */
+    using INHERITED::reset;
 
     bool isValid() const { return kInvalidResourceType != this->resourceType(); }
 
-    ResourceType resourceType() const { return fKey[kTypeAndSize_MetaDataIdx] & 0xffff; }
-
-    uint32_t hash() const { return fKey[kHash_MetaDataIdx]; }
-
-    size_t size() const { return SkToInt(fKey[kTypeAndSize_MetaDataIdx] >> 16); }
-
-    const uint32_t* data() const { return &fKey[kMetaDataCnt]; }
+    ResourceType resourceType() const { return this->domain(); }
 
     GrScratchKey& operator=(const GrScratchKey& that) {
-        size_t bytes = that.size();
-        fKey.reset(SkToInt(bytes / sizeof(uint32_t)));
-        memcpy(fKey.get(), that.fKey.get(), bytes);
+        this->INHERITED::operator=(that);
         return *this;
     }
 
     bool operator==(const GrScratchKey& that) const {
-        return 0 == memcmp(fKey.get(), that.fKey.get(), this->size());
+        return this->INHERITED::operator==(that);
     }
     bool operator!=(const GrScratchKey& that) const { return !(*this == that); }
 
-    /** Used to initialize scratch key. */
-    class Builder {
+    class Builder : public INHERITED::Builder {
     public:
-        Builder(GrScratchKey* key, ResourceType type, int data32Count) : fKey(key) {
-            SkASSERT(data32Count >= 0);
-            SkASSERT(type != kInvalidResourceType);
-            key->fKey.reset(kMetaDataCnt + data32Count);
-            SkASSERT(type <= SK_MaxU16);
-            int size = (data32Count + kMetaDataCnt) * sizeof(uint32_t);
-            SkASSERT(size <= SK_MaxU16);
-            key->fKey[kTypeAndSize_MetaDataIdx] = type | (size << 16);
-        }
-
-        ~Builder() { this->finish(); }
-
-        void finish();
-
-        uint32_t& operator[](int dataIdx) {
-            SkASSERT(fKey);
-            SkDEBUGCODE(size_t dataCount = fKey->size() / sizeof(uint32_t) - kMetaDataCnt;)
-            SkASSERT(SkToU32(dataIdx) < dataCount);
-            return fKey->fKey[kMetaDataCnt + dataIdx];
-        }
-
+        Builder(GrScratchKey* key, ResourceType type, int data32Count)
+            : INHERITED(key, type, data32Count) {}
     private:
-        GrScratchKey* fKey;
-    };
-
+        typedef INHERITED::Builder INHERITED;
+    };
+};
+
+/**
+ * A key used to cache resources based on their content. The key consists of a domain type (use
+ * case for the cache), a hash, a data length, and domain-specific data. A Builder object is used to
+ * initialize the key contents. The contents must be initialized before the key can be used.
+ */
+class GrContentKey : public GrResourceKey {

[robertphillips, 2015/01/22 16:49:12]

Shouldn't this be at the end ?

 private:
-    enum MetaDataIdx {
-        kHash_MetaDataIdx,
-        // The resource type and size are packed into a single uint32_t.
-        kTypeAndSize_MetaDataIdx,
-
-        kLastMetaDataIdx = kTypeAndSize_MetaDataIdx
-    };
-    static const uint32_t kInvalidResourceType = 0;
-    static const uint32_t kMetaDataCnt = kLastMetaDataIdx + 1;
-
-    friend class TestResource; // For unit test to access kMetaDataCnt.
-
-    // Stencil and textures each require 2 uint32_t values.
-    SkAutoSTArray<kMetaDataCnt + 2, uint32_t> fKey;
+    typedef GrResourceKey INHERITED;
+
+public:

[robertphillips, 2015/01/22 16:49:11]

Can this be hidden ?

[bsalomon, 2015/01/22 19:23:17]

Removed it.

+    static const uint32_t kInvalidDomain = INHERITED::kInvalidDomain;
+
+    typedef uint32_t Domain;
+    /** Generate a unique Domain of content keys. */
+    static Domain GenerateDomain();
+
+    /** Creates an invalid content key. It must be initialized using a Builder object before use. */
+    GrContentKey() {}
+
+    GrContentKey(const GrContentKey& that) { *this = that; }
+
+    /** reset() returns the key to the invalid state. */
+    using INHERITED::reset;
+

[robertphillips, 2015/01/22 16:49:12]

return this->INHERITED::isValid(); ?

[bsalomon, 2015/01/22 19:23:17]

Done.

+    bool isValid() const { return kInvalidDomain != this->domain(); }
+
+    GrContentKey& operator=(const GrContentKey& that) {
+        this->INHERITED::operator=(that);
+        return *this;
+    }
+
+    bool operator==(const GrContentKey& that) const {
+        return this->INHERITED::operator==(that);
+    }
+    bool operator!=(const GrContentKey& that) const { return !(*this == that); }
+
+    class Builder : public INHERITED::Builder {
+    public:
+        Builder(GrContentKey* key, Domain domain, int data32Count)
+            : INHERITED(key, domain, data32Count) {}
+
+        /** Used to build a key that wraps another key and adds additional data. */
+        Builder(GrContentKey* key, const GrContentKey& innerKey, Domain domain,
+                int extraData32Cnt)
+            : INHERITED(key, domain, (SkToInt(innerKey.size()) >> 2) + extraData32Cnt) {
+            int innerKeyCnt = SkToInt(innerKey.size()) >> 2;
+            for (int i = 0; i < innerKeyCnt; ++i) {

[robertphillips, 2015/01/22 16:49:12]

Maybe move this comment up ?

[bsalomon, 2015/01/22 19:23:17]

Done.

+                // add the inner key to the end of the key so that op[] can be indexed normally.
+                this->operator[](extraData32Cnt + i) = innerKey.data()[i];
+            }
+        }
+    private:
+        typedef INHERITED::Builder INHERITED;
+    };
 };
 
-class GrResourceKey {
-public:
-    /** Flags set by the GrGpuResource subclass. */
-    typedef uint8_t ResourceFlags;
-
-    /** Creates a key for resource */
-    GrResourceKey(const GrCacheID& id, ResourceFlags flags) {
-        this->init(id.getDomain(), id.getKey(), flags);
-    };
-
-    GrResourceKey(const GrResourceKey& src) { fKey = src.fKey; }
-
-    GrResourceKey() { fKey.reset(); }
-
-    void reset(const GrCacheID& id, ResourceFlags flags) {
-        this->init(id.getDomain(), id.getKey(), flags);
-    }
-
-    uint32_t getHash() const { return fKey.getHash(); }
-
-    ResourceFlags getResourceFlags() const {
-        return *reinterpret_cast<const ResourceFlags*>(fKey.getData() +
-                                                       kResourceFlagsOffset);
-    }
-
-    bool operator==(const GrResourceKey& other) const { return fKey == other.fKey; }
-
-    // A key indicating that the resource is not usable as a scratch resource.
-    static GrResourceKey& NullScratchKey();
-
-private:
-    enum {
-        kCacheIDKeyOffset = 0,
-        kCacheIDDomainOffset = kCacheIDKeyOffset + sizeof(GrCacheID::Key),
-        kResourceFlagsOffset = kCacheIDDomainOffset + sizeof(GrCacheID::Domain),
-        kPadOffset = kResourceFlagsOffset + sizeof(ResourceFlags),
-        kKeySize = SkAlign4(kPadOffset),
-        kPadSize = kKeySize - kPadOffset
-    };
-
-    void init(const GrCacheID::Domain domain, const GrCacheID::Key& key, ResourceFlags flags) {
-        union {
-            uint8_t  fKey8[kKeySize];
-            uint32_t fKey32[kKeySize / 4];
-        } keyData;
-
-        uint8_t* k = keyData.fKey8;
-        memcpy(k + kCacheIDKeyOffset, key.fData8, sizeof(GrCacheID::Key));
-        memcpy(k + kCacheIDDomainOffset, &domain, sizeof(GrCacheID::Domain));
-        memcpy(k + kResourceFlagsOffset, &flags, sizeof(ResourceFlags));
-        memset(k + kPadOffset, 0, kPadSize);
-        fKey.setKeyData(keyData.fKey32);
-    }
-    GrBinHashKey<kKeySize> fKey;
-};
-
 #endif