ResourceKey.h File Reference

#include "include/core/SkData.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkTypes.h"
#include "include/private/base/SkAlign.h"
#include "include/private/base/SkAlignedStorage.h"
#include "include/private/base/SkDebug.h"
#include "include/private/base/SkTemplates.h"
#include "include/private/base/SkTo.h"
#include <cstdint>
#include <cstring>
#include <new>
#include <utility>

Go to the source code of this file.

Classes
class	skgpu::ResourceKey
class	skgpu::ResourceKey::Builder
class	skgpu::ScratchKey
class	skgpu::ScratchKey::Builder
class	skgpu::UniqueKey
class	skgpu::UniqueKey::Builder
class	skgpu::UniqueKeyInvalidatedMessage
class	skgpu::UniqueKeyInvalidatedMsg_Graphite

Namespaces
namespace	skgpu

Macros
#define	SKGPU_DECLARE_STATIC_UNIQUE_KEY(name)   static SkOnce name##_once
#define	SKGPU_DEFINE_STATIC_UNIQUE_KEY(name)

Functions
uint32_t	skgpu::ResourceKeyHash (const uint32_t *data, size_t size)
static void	skgpu::skgpu_init_static_unique_key_once (SkAlignedSTStorage< 1, UniqueKey > *keyStorage)
static bool	skgpu::SkShouldPostMessageToBus (const UniqueKeyInvalidatedMessage &msg, uint32_t msgBusUniqueID)
static bool	skgpu::SkShouldPostMessageToBus (const UniqueKeyInvalidatedMsg_Graphite &msg, uint32_t msgBusUniqueID)

Macro Definition Documentation

SKGPU_DECLARE_STATIC_UNIQUE_KEY

#define SKGPU_DECLARE_STATIC_UNIQUE_KEY

(

name

)

static SkOnce name##_once

It is common to need a frequently reused UniqueKey where the only requirement is that the key is unique. These macros create such a key in a thread safe manner so the key can be truly global and only constructed once. Place outside of function/class definitions.

Definition at line 321 of file ResourceKey.h.

SKGPU_DEFINE_STATIC_UNIQUE_KEY

#define SKGPU_DEFINE_STATIC_UNIQUE_KEY

(

name

)

Value:

    static SkAlignedSTStorage<1, skgpu::UniqueKey> name##_storage;          \
    name##_once(skgpu::skgpu_init_static_unique_key_once, &name##_storage); \
    static const skgpu::UniqueKey& name =                                   \
        *reinterpret_cast<skgpu::UniqueKey*>(name##_storage.get())

Place inside function where the key is used.

Definition at line 324 of file ResourceKey.h.

                                                                                                   {
    UniqueKey* key = new (keyStorage->get()) UniqueKey;
    UniqueKey::Builder builder(key, UniqueKey::GenerateDomain(), 0);
}
 
// The cache listens for these messages to purge junk resources proactively.
class UniqueKeyInvalidatedMessage {
public:
    UniqueKeyInvalidatedMessage() = default;
    UniqueKeyInvalidatedMessage(const UniqueKey& key,
                                uint32_t contextUniqueID,
                                bool inThreadSafeCache = false)
            : fKey(key), fContextID(contextUniqueID), fInThreadSafeCache(inThreadSafeCache) {
        SkASSERT(SK_InvalidUniqueID != contextUniqueID);
    }
 
    UniqueKeyInvalidatedMessage(const UniqueKeyInvalidatedMessage&) = default;
 
    UniqueKeyInvalidatedMessage& operator=(const UniqueKeyInvalidatedMessage&) = default;
 
    const UniqueKey& key() const { return fKey; }
    uint32_t contextID() const { return fContextID; }
    bool inThreadSafeCache() const { return fInThreadSafeCache; }
 
private:
    UniqueKey fKey;
    uint32_t fContextID = SK_InvalidUniqueID;
    bool fInThreadSafeCache = false;
};
 
static inline bool SkShouldPostMessageToBus(const UniqueKeyInvalidatedMessage& msg,
                                            uint32_t msgBusUniqueID) {
    return msg.contextID() == msgBusUniqueID;
}
 
class UniqueKeyInvalidatedMsg_Graphite {
public:
    UniqueKeyInvalidatedMsg_Graphite() = default;
    UniqueKeyInvalidatedMsg_Graphite(const UniqueKey& key, uint32_t recorderID)
            : fKey(key), fRecorderID(recorderID) {
        SkASSERT(SK_InvalidUniqueID != fRecorderID);
    }
 
    UniqueKeyInvalidatedMsg_Graphite(const UniqueKeyInvalidatedMsg_Graphite&) = default;
 
    UniqueKeyInvalidatedMsg_Graphite& operator=(const UniqueKeyInvalidatedMsg_Graphite&) = default;
 
    const UniqueKey& key() const { return fKey; }
    uint32_t recorderID() const { return fRecorderID; }
 
private:
    UniqueKey fKey;
    uint32_t fRecorderID = SK_InvalidUniqueID;
};
 
static inline bool SkShouldPostMessageToBus(const UniqueKeyInvalidatedMsg_Graphite& msg,
                                            uint32_t msgBusUniqueID) {
    return msg.recorderID() == msgBusUniqueID;
}
 
} // namespace skgpu
 
#endif // skgpu_ResourceKey_DEFINED